omniai 1.9.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23098dd1fbbb9542265f3d32a9c37642a1a554fa4a789c78fb4e25a364213116
-  data.tar.gz: 4885f37cc46af15c1e208a6c9c4f0f06b84d4986c1d0b9361fd2b9e451fb3352
+  metadata.gz: 116095cbb73cb4e826fe28a4c644e37ea1ecb887d601b0ca4cbdc3a70e0ca81e
+  data.tar.gz: d17b5078d80e7cf6858b0e77e22d5949c157841672aa5bbe54a2782e8e10df31
 SHA512:
-  metadata.gz: a63e630e0aeeeb8342cceba0d2505c487e9dacfcd76bcc07e75d8c29c132a9806d3d4fdc4346ebcd6a6eb02534a14de75f9bd5530388eec1652ff19a61b2d008
-  data.tar.gz: a61425c68913a53de2d0300fe3c74ea546491f69fffd53c1c6fbd414924b7204b718c7676de5b604a063532a8149bbaef132032b1cbc49ac0e69d9030bfd456e
+  metadata.gz: 5b3a610780db624592fab65b2437ac552de7dd9f7d5c4f6ec62aff546720db832a40f4a7e24e68d64f42ce84dff24ed73a3105a08c37c61f00faa83d65fd55ca
+  data.tar.gz: 5000a20feca11ee1e29b03d71885d4e75aa6792a39ac828ae78b3fcae5783430f65fe93b209350aa3399dfc7cce1ccbadc0a844518e0ccb772d0b8704f304cc3

data/lib/omniai/chat/choice.rb

@@ -54,13 +54,6 @@ module OmniAI
         }
       end
 
-      # @param other [OmniAI::Chat::Choice]
-      #
-      # @return [OmniAI::Chat::Choice]
-      def merge(other)
-        self.class.new(index: @index, message: @message.merge(other.message))
-      end
-
       # @return [Message]
       def delta
         message

data/lib/omniai/chat/delta.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # An `OmniAI::Chat::Delta` is used to assist with streaming. It represents a chunk of a conversation that is yielded
+    # back to the caller.
+    class Delta
+      # @!attribute [rw] text
+      #
+      attr_accessor :text
+
+      # @param text [String]
+      def initialize(text:)
+        @text = text
+      end
+
+      # @return [Boolean]
+      def text?
+        !text.empty?
+      end
+    end
+  end
+end

data/lib/omniai/chat/function.rb

@@ -4,10 +4,12 @@ module OmniAI
   class Chat
     # A function that includes a name / arguments.
     class Function
-      # @return [String]
+      # @!attribute [rw] name
+      #   @return [String]
       attr_accessor :name
 
-      # @return [Hash]
+      # @!attribute [rw] arguments
+      #   @return [Hash]
       attr_accessor :arguments
 
       # @param name [String]

data/lib/omniai/chat/message.rb

@@ -47,12 +47,12 @@ module OmniAI
       attr_accessor :role
 
       # @!attribute [rw] tool_call_list
-      #   @return [Array<ToolCall>, nil]
+      #   @return [ToolCallList, nil]
       attr_accessor :tool_call_list
 
       # @param content [String, nil]
       # @param role [String]
-      # @param tool_call_list [Array<ToolCall>, nil]
+      # @param tool_call_list [ToolCallList, nil]
       def initialize(content:, role: Role::USER, tool_call_list: nil)
         @content = content
         @role = role
@@ -86,7 +86,7 @@ module OmniAI
 
         role = data["role"]
         content = Content.deserialize(data["content"], context:)
-        tool_call_list = data["tool_calls"]&.map { |subdata| ToolCall.deserialize(subdata, context:) }
+        tool_call_list = ToolCallList.deserialize(data["tool_calls"], context:)
 
         new(content:, role:, tool_call_list:)
       end
@@ -104,32 +104,11 @@ module OmniAI
         return serializer.call(self, context:) if serializer
 
         content = @content.is_a?(Array) ? @content.map { |content| content.serialize(context:) } : @content
-        tool_calls = @tool_call_list&.map { |tool_call| tool_call.serialize(context:) }
+        tool_calls = @tool_call_list&.serialize(context:)
 
         { role: @role, content:, tool_calls: }.compact
       end
 
-      # @param other [OmniAI::Chat::Message]
-      #
-      # @return [OmniAI::Chat::Message]
-      def merge(other)
-        content =
-          if @content && other.content
-            @content + other.content
-          else
-            @content || other.content
-          end
-
-        tool_call_list =
-          if @tool_call_list && other.tool_call_list
-            @tool_call_list + other.tool_call_list
-          else
-            @tool_call_list || other.tool_call_list
-          end
-
-        self.class.new(content:, role:, tool_call_list:)
-      end
-
       # @return [Boolean]
       def role?(role)
         String(@role).eql?(String(role))

data/lib/omniai/chat/response.rb

@@ -2,68 +2,116 @@
 
 module OmniAI
   class Chat
-    # Used when processing everything at once.
+    # An `OmniAI::Chat::Response` encapsulates the result of generating a chat completion.
     class Response
       # @return [Hash]
       attr_accessor :data
 
+      # @return [Array<Choice>]
+      attr_accessor :choices
+
+      # @return [Usage, nil]
+      attr_accessor :usage
+
       # @param data [Hash]
-      # @param context [Context, nil]
-      def initialize(data:, context: nil)
+      # @param choices [Array<Choice>]
+      # @param usage [Usage, nil]
+      def initialize(data:, choices: [], usage: nil)
         @data = data
-        @context = context
+        @choices = choices
+        @usage = usage
       end
 
-      # @return [Payload]
-      def completion
-        @completion ||= Payload.deserialize(@data, context: @context)
+      # @return [String]
+      def inspect
+        "#<#{self.class.name} choices=#{choices.inspect} usage=#{usage.inspect}>"
       end
 
-      # @return [Usage, nil]
-      def usage
-        completion.usage
-      end
+      # @param data [Hash]
+      # @param context [OmniAI::Context] optional
+      def self.deserialize(data, context: nil)
+        deserialize = context&.deserializer(:response)
+        return deserialize.call(data, context:) if deserialize
 
-      # @return [Array<Choice>]
-      def choices
-        completion.choices
+        choices = data["choices"].map { |choice_data| Choice.deserialize(choice_data, context:) }
+        usage = Usage.deserialize(data["usage"], context:) if data["usage"]
+
+        new(data:, choices:, usage:)
       end
 
-      # @return [Array<Message>]
-      def messages
-        completion.messages
+      # @param context [OmniAI::Context] optional
+      # @return [Hash]
+      def serialize(context:)
+        serialize = context&.serializer(:response)
+        return serialize.call(self, context:) if serialize
+
+        {
+          choices: choices.map { |choice| choice.serialize(context:) },
+          usage: usage&.serialize(context:),
+        }
       end
 
       # @param index [Integer]
-      # @return [Choice]
+      #
+      # @return [Choice, nil]
       def choice(index: 0)
-        completion.choice(index:)
+        @choices[index]
+      end
+
+      # @param index [Integer]
+      #
+      # @return [Boolean]
+      def choice?(index: 0)
+        !choice(index:).nil?
       end
 
       # @param index [Integer]
-      # @return [Message]
+      #
+      # @return [Message, nil]
       def message(index: 0)
-        completion.message(index:)
+        choice(index:)&.message
       end
 
-      # @return [String]
-      def text
-        message.text
+      # @param index [Integer]
+      #
+      # @return [Boolean]
+      def message?
+        !message(index:).nil?
+      end
+
+      # @return [Array<Message>]
+      def messages
+        @choices.map(&:message)
+      end
+
+      # @param index [Integer]
+      #
+      # @return [String, nil]
+      def text(index: 0)
+        message(index:)&.text
       end
 
+      # @param index [Integer]
+      #
       # @return [Boolean]
-      def text?
-        message.text?
+      def text?(index: 0)
+        message = message(index:)
+
+        !message.nil? && message.text?
       end
 
-      # @return [Array<ToolCall>]
-      def tool_call_list
-        choice.tool_call_list
+      # @param index [Integer]
+      #
+      # @return [ToolCallList]
+      def tool_call_list(index: 0)
+        message(index:)&.tool_call_list
       end
 
       # @return [Boolean]
-      def tool_call_list?
-        tool_call_list&.any?
+      def tool_call_list?(index: 0)
+        tool_call_list = tool_call_list(index:)
+
+        !tool_call_list.nil? && tool_call_list.any?
       end
     end
   end

data/lib/omniai/chat/stream.rb

@@ -13,30 +13,32 @@ module OmniAI
     class Stream
       # @param logger [OmniAI::Client]
       # @param chunks [Enumerable<String>]
-      # @param context [Context, nil]
-      def initialize(chunks:, logger: nil, context: nil)
+      def initialize(chunks:, logger: nil)
         @chunks = chunks
         @logger = logger
-        @context = context
       end
 
-      # @yield [payload]
-      # @yieldparam payload [OmniAI::Chat::Payload]
+      # @yield [delta]
+      # @yieldparam delta [OmniAI::Chat::Delta]
       #
-      # @return [OmniAI::Chat::Payload]
+      # @return [Hash]
       def stream!(&block)
-        OmniAI::Chat::Payload.new.tap do |payload|
-          @chunks.map do |chunk|
-            parser.feed(chunk) do |type, data, id|
-              result = process!(type, data, id, &block)
-              payload.merge!(result) if result.is_a?(OmniAI::Chat::Payload)
-            end
+        @data = { "choices" => [] }
+
+        @chunks.map do |chunk|
+          parser.feed(chunk) do |type, data, id|
+            process!(type, data, id, &block)
           end
         end
+
+        @data
       end
 
     protected
 
+      # @yield [delta]
+      # @yieldparam delta [OmniAI::Chat::Delta]
+      #
       # @param type [String]
       # @param data [String]
       # @param id [String]
@@ -50,19 +52,78 @@ module OmniAI
         @logger&.debug("Stream#process! #{arguments.join(' ')}")
       end
 
+      # @yield [delta]
+      # @yieldparam delta [OmniAI::Chat::Delta]
+      #
       # @param type [String]
       # @param data [String]
       # @param id [String]
-      #
-      # @return [OmniAI::Chat::Payload, nil]
-      def process!(type, data, id, &block)
+      def process!(type, data, id, &)
         log(type, data, id)
 
         return if data.eql?("[DONE]")
 
-        payload = Payload.deserialize(JSON.parse(data), context: @context)
-        block&.call(payload)
-        payload
+        process_data!(data: JSON.parse(data), &)
+      end
+
+      # @yield [delta]
+      # @yieldparam delta [OmniAI::Chat::Delta]
+      #
+      # @param data [Hash]
+      def process_data!(data:, &block)
+        data.each do |key, value|
+          @data[key] = value unless key.eql?("choices") || key.eql?("object")
+        end
+
+        data["choices"].each do |choice|
+          merge_choice!(choice:)
+
+          text = choice["delta"]["content"]
+          block&.call(Delta.new(text:)) if text
+        end
+      end
+
+      # @param choice [Hash]
+      def merge_choice!(choice:)
+        index = choice["index"]
+        delta = choice["delta"]
+
+        if @data["choices"][index].nil?
+          @data["choices"][index] = {
+            "index" => index,
+            "message" => delta,
+          }
+        else
+          message = @data["choices"][index]["message"]
+
+          message["content"] += delta["content"] if delta["content"]
+
+          merge_tool_call_list!(tool_call_list: delta["tool_calls"], message:)
+        end
+      end
+
+      # @param tool_call_list [Array<Hash>, nil]
+      # @param message [Hash]
+      def merge_tool_call_list!(tool_call_list:, message:)
+        return unless tool_call_list
+
+        message["tool_calls"] ||= []
+
+        tool_call_list.each do |tool_call|
+          merge_tool_call_data!(tool_call:, message:)
+        end
+      end
+
+      # @param tool_call [Hash]
+      # @param message [Hash]
+      def merge_tool_call_data!(tool_call:, message:)
+        tool_call_index = tool_call["index"]
+
+        if message["tool_calls"][tool_call_index].nil?
+          message["tool_calls"][tool_call_index] = tool_call
+        else
+          message["tool_calls"][tool_call_index]["function"]["arguments"] += tool_call["function"]["arguments"]
+        end
       end
 
       # @return [EventStreamParser::Parser]

data/lib/omniai/chat/tool_call.rb

@@ -4,10 +4,12 @@ module OmniAI
   class Chat
     # A tool-call that includes an ID / function.
     class ToolCall
-      # @return [String]
+      # @!attribute [rw] id
+      #   @return [String]
       attr_accessor :id
 
-      # @return [Function]
+      # @!attribute [rw] function
+      #   @return [Function]
       attr_accessor :function
 
       # @param id [String]
@@ -25,7 +27,7 @@ module OmniAI
       # @param data [Hash]
       # @param context [Context] optional
       #
-      # @return [Function]
+      # @return [ToolCall]
       def self.deserialize(data, context: nil)
         deserialize = context&.deserializer(:tool_call)
         return deserialize.call(data, context:) if deserialize

data/lib/omniai/chat/tool_call_list.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # An `OmniAI::Chat::ToolCallList` is a collection designed to handle the merging of multiple tool call arrays. LLMs
+    # provide a subset of tool call items when chunking, so merging requires the use of the tool call index to combine.
+    class ToolCallList
+      include Enumerable
+
+      # @param entries [Array<ToolCall>]
+      def initialize(entries: [])
+        @entries = entries
+      end
+
+      # Usage:
+      #
+      #   ToolCallList.deserialize([]) # => #<ToolCallList ...>
+      #
+      # @param data [Array]
+      # @param context [Context] optional
+      #
+      # @return [ToolCallList]
+      def self.deserialize(data, context: nil)
+        return unless data
+
+        new(entries: data.map { |subdata| ToolCall.deserialize(subdata, context:) })
+      end
+
+      # Usage:
+      #
+      #   tool_call_list.serialize # => [...]
+      #
+      # @param context [Context] optional
+      #
+      # @return [Array<Hash>]
+      def serialize(context: nil)
+        @entries.compact.map { |tool_call| tool_call.serialize(context:) }
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class.name} entries=#{@entries.inspect}>"
+      end
+
+      # @yield toolcall
+      # @yieldparam toolcall [ToolCall]
+      def each(&)
+        @entries.each(&)
+      end
+    end
+  end
+end

data/lib/omniai/chat/tool_call_message.rb

@@ -28,7 +28,7 @@ module OmniAI
       #
       # @return [ToolMessage]
       def self.deserialize(data, context: nil)
-        deserialize = context&.deserializer(:tool_message)
+        deserialize = context&.deserializer(:tool_call_message)
         return deserialize.call(data, context:) if deserialize
 
         role = data["role"]
@@ -47,7 +47,7 @@ module OmniAI
       #
       # @return [Hash]
       def serialize(context: nil)
-        serializer = context&.serializer(:tool_message)
+        serializer = context&.serializer(:tool_call_message)
         return serializer.call(self, context:) if serializer
 
         role = @role

data/lib/omniai/chat.rb

@@ -86,12 +86,25 @@ module OmniAI
     end
 
     # @raise [HTTPError]
+    #
+    # @return [OmniAI::Chat::Response]
     def process!
       response = request!
 
       raise HTTPError, response.flush unless response.status.ok?
 
-      parse!(response:)
+      completion = parse!(response:)
+
+      if @tools && completion.tool_call_list?
+        spawn!(
+          @prompt.dup.tap do |prompt|
+            prompt.messages += completion.messages
+            prompt.messages += build_tool_call_messages(completion.tool_call_list)
+          end
+        ).process!
+      else
+        completion
+      end
     end
 
   protected
@@ -135,6 +148,7 @@ module OmniAI
     end
 
     # @param response [HTTP::Response]
+    #
     # @return [OmniAI::Chat::Response]
     def parse!(response:)
       if @stream
@@ -145,32 +159,22 @@ module OmniAI
     end
 
     # @param response [HTTP::Response]
+    #
     # @return [OmniAI::Chat::Response]
     def complete!(response:)
-      completion = self.class::Response.new(data: response.parse, context:)
-
-      if @tools && completion.tool_call_list?
-        spawn!(
-          @prompt.dup.tap do |prompt|
-            prompt.messages += completion.messages
-            prompt.messages += build_tool_call_messages(completion.tool_call_list)
-          end
-        ).process!
-      else
-        completion
-      end
+      OmniAI::Chat::Response.deserialize(response.parse, context:)
     end
 
     # @param response [HTTP::Response]
     #
-    # @return [OmniAI::Chat::Payload]
+    # @return [OmniAI::Chat::Response]
     def stream!(response:)
       raise Error, "#{self.class.name}#stream! unstreamable" unless @stream
 
-      payload = self.class::Stream.new(chunks: response.body, logger:, context:).stream! do |chunk|
+      data = self.class::Stream.new(chunks: response.body, logger:).stream! do |chunk|
         case @stream
         when IO, StringIO
-          if chunk.text
+          if chunk.text?
             @stream << chunk.text
             @stream.flush
           end
@@ -178,9 +182,11 @@ module OmniAI
         end
       end
 
-      @stream.puts if @stream.is_a?(IO) || @stream.is_a?(StringIO)
+      response = OmniAI::Chat::Response.deserialize(data, context:)
+
+      @stream.puts if response.text? && (@stream.is_a?(IO) || @stream.is_a?(StringIO))
 
-      payload
+      response
     end
 
     # @return [HTTP::Response]

data/lib/omniai/client.rb

@@ -134,7 +134,7 @@ module OmniAI
     # @yield [prompt] optional
     # @yieldparam prompt [OmniAI::Chat::Prompt]
     #
-    # @return [OmniAI::Chat::Completion]
+    # @return [OmniAI::Chat::Response]
     def chat(messages = nil, 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.9.6"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: omniai
 version: !ruby/object:Gem::Version
-  version: 1.9.6
+  version: 2.0.0
 platform: ruby
 authors:
 - Kevin Sylvestre
 bindir: exe
 cert_chain: []
-date: 2025-02-27 00:00:00.000000000 Z
+date: 2025-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -83,17 +83,18 @@ files:
 - lib/omniai/chat.rb
 - lib/omniai/chat/choice.rb
 - lib/omniai/chat/content.rb
+- lib/omniai/chat/delta.rb
 - lib/omniai/chat/file.rb
 - lib/omniai/chat/function.rb
 - lib/omniai/chat/media.rb
 - lib/omniai/chat/message.rb
 - lib/omniai/chat/message/builder.rb
-- lib/omniai/chat/payload.rb
 - lib/omniai/chat/prompt.rb
 - lib/omniai/chat/response.rb
 - lib/omniai/chat/stream.rb
 - lib/omniai/chat/text.rb
 - lib/omniai/chat/tool_call.rb
+- lib/omniai/chat/tool_call_list.rb
 - lib/omniai/chat/tool_call_message.rb
 - lib/omniai/chat/tool_call_result.rb
 - lib/omniai/chat/url.rb

data/lib/omniai/chat/payload.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module OmniAI
-  class Chat
-    # A chunk or completion.
-    class Payload
-      # @return [Array<Choice>]
-      attr_accessor :choices
-
-      # @return [Usage, nil]
-      attr_accessor :usage
-
-      # @param choices [Array<Choice>]
-      # @param usage [Usage, nil]
-      def initialize(choices: [], usage: nil)
-        @id = SecureRandom.alphanumeric
-        @choices = choices
-        @usage = usage
-      end
-
-      # @return [String]
-      def inspect
-        "#<#{self.class.name} choices=#{choices.inspect} usage=#{usage.inspect}>"
-      end
-
-      # @param data [Hash]
-      # @param context [OmniAI::Context] optional
-      def self.deserialize(data, context: nil)
-        deserialize = context&.deserializer(:payload)
-        return deserialize.call(data, context:) if deserialize
-
-        choices = data["choices"].map { |choice_data| Choice.deserialize(choice_data, context:) }
-        usage = Usage.deserialize(data["usage"], context:) if data["usage"]
-
-        new(choices:, usage:)
-      end
-
-      # @param context [OmniAI::Context] optional
-      # @return [Hash]
-      def serialize(context:)
-        serialize = context&.serializer(:payload)
-        return serialize.call(self, context:) if serialize
-
-        {
-          choices: choices.map { |choice| choice.serialize(context:) },
-          usage: usage&.serialize(context:),
-        }
-      end
-
-      # @param other [OmniAI::Chat::Payload]
-      def merge!(other)
-        return unless other
-
-        @usage = other.usage if other.usage
-
-        other.choices.each do |choice|
-          if choice?(index: choice.index)
-            choices[choice.index] = choices[choice.index].merge(choice)
-          else
-            @choices[choice.index] = choice
-          end
-        end
-      end
-
-      # @param index [Integer]
-      # @return [Choice]
-      def choice(index: 0)
-        @choices[index]
-      end
-
-      # @param index [Integer]
-      # @return [Boolean]
-      def choice?(index: 0)
-        !choice(index:).nil?
-      end
-
-      # @param index [Integer]
-      # @return [Message]
-      def message(index: 0)
-        choice(index:).message
-      end
-
-      # @return [Array<Message>]
-      def messages
-        @choices.map(&:message)
-      end
-
-      # @param index [Integer]
-      # @return [String, nil]
-      def text(index: 0)
-        message(index:).text
-      end
-
-      # @param index [Integer]
-      # @return [Boolean]
-      def text?(index: 0)
-        message(index:).text?
-      end
-
-      # @param index [Integer]
-      # @return [Array<ToolCall>]
-      def tool_call_list(index:)
-        message(index:).tool_call_list
-      end
-    end
-  end
-end