omniai 1.9.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c57a422d4d3213f3d952940908890c4da086668972a6596f4ce69530af1bf547
-  data.tar.gz: a66bb5326ce64219cc58ab1f072ef40741ae03a83aecd86d96a6417767911c5b
+  metadata.gz: 116095cbb73cb4e826fe28a4c644e37ea1ecb887d601b0ca4cbdc3a70e0ca81e
+  data.tar.gz: d17b5078d80e7cf6858b0e77e22d5949c157841672aa5bbe54a2782e8e10df31
 SHA512:
-  metadata.gz: 832c57105c19df9bf3675a1050cae1bdb775cd117a4222b81ee7032abf5356007fa04f7282017585da7563855d0e6ddc55aa8f330a9dfdceb22b0b9f632c2f96
-  data.tar.gz: d202c4bc08eaefa7b5ec08c3192c0fa08f6938fbd3feade8018d65c4a46cb56d078194b072b2b483388c6fca736fa334e3f717fb14d607123425ce250f969488
+  metadata.gz: 5b3a610780db624592fab65b2437ac552de7dd9f7d5c4f6ec62aff546720db832a40f4a7e24e68d64f42ce84dff24ed73a3105a08c37c61f00faa83d65fd55ca
+  data.tar.gz: 5000a20feca11ee1e29b03d71885d4e75aa6792a39ac828ae78b3fcae5783430f65fe93b209350aa3399dfc7cce1ccbadc0a844518e0ccb772d0b8704f304cc3

data/README.md

@@ -6,7 +6,7 @@
 [![Yard](https://img.shields.io/badge/docs-site-blue.svg)](https://omniai.ksylvest.com)
 [![CircleCI](https://img.shields.io/circleci/build/github/ksylvest/omniai)](https://circleci.com/gh/ksylvest/omniai)
 
-OmniAI standardizes the APIs of various AI / LLM companies such as Anthropic, Google, Mistral and OpenAI for the generation of text, the conversion of text-to-speech, the conversion of speech-to-text, the generation of embeddings, and more. It offers a unified API regardless of the provider and task.
+OmniAI provides a unified Ruby API for integrating with multiple AI providers, including Anthropic, DeepSeek, Google, Mistral, and OpenAI. It streamlines AI development by offering a consistent interface for features such as chat, text-to-speech, speech-to-text, and embeddings—ensuring seamless interoperability across platforms. Switching between providers is effortless, making any integration more flexible and reliable.
 
 - [OmniAI::Anthropic](https://github.com/ksylvest/omniai-anthropic)
 - [OmniAI::DeepSeek](https://github.com/ksylvest/omniai-deepseek)
@@ -18,6 +18,8 @@ OmniAI standardizes the APIs of various AI / LLM companies such as Anthropic, Go
 
 ### Example #1: [Chat](https://github.com/ksylvest/omniai/blob/main/examples/chat)
 
+This example demonstrates using `OmniAI` with **Anthropic** to prompt a “biologist” for an analysis of photos, identifying the animals within each one. A system and user message are provided, and the response is streamed in real time.
+
 ```ruby
 require 'omniai/anthropic'
 
@@ -45,6 +47,8 @@ The animals in the photos are:
 
 ### Example #2: [Text-to-Speech](https://github.com/ksylvest/omniai/blob/main/examples/text_to_speech)
 
+This example demonstrates using `OmniAI` with **OpenAI** to convert text to speech and save it to a file.
+
 ```ruby
 require 'omniai/openai'
 
@@ -59,6 +63,8 @@ end
 
 ### Example #3: [Speech-to-Text](https://github.com/ksylvest/omniai/blob/main/examples/speech_to_text)
 
+This example demonstrates using `OmniAI` with **OpenAI** to convert speech to text.
+
 ```ruby
 require 'omniai/openai'
 
@@ -72,6 +78,8 @@ end
 
 ### Example #4: [Tools](https://github.com/ksylvest/omniai/blob/main/examples/tools)
 
+This example demonstrates how to use `OmniAI` with **Google** to call a custom tool that generates a weather report. The tool accepts a list of locations (city and country) and returns a temperature — randomly generated for demonstration purposes — based on the provided parameters.
+
 ```ruby
 require 'omniai/google'
 
@@ -127,6 +135,8 @@ The weather is 24° celcius in London and 42° fahrenheit in Seattle.
 
 ### Example #5: [Embeddings](https://github.com/ksylvest/omniai/blob/main/examples/embeddings)
 
+This example demonstrates using `OmniAI` with **Mistral** to generate embeddings for a dataset. It defines a set of entries (e.g. "George is a teacher." or "Ringo is a doctor.") and then compares the embeddings generated from a query (e.g. "What does George do?" or "Who is a doctor?") to rank the entries by relevance.
+
 ```ruby
 require 'omniai/mistral'
 

data/lib/omniai/chat/choice.rb

@@ -5,15 +5,20 @@ module OmniAI
     # A choice wraps a message and index returned by an LLM. The default is to generate a single choice. Some LLMs
     # support generating multiple choices at once (e.g. giving you multiple options to choose from).
     class Choice
-      # @return [Integer]
+      DEFAULT_INDEX = 0
+      private_constant :DEFAULT_INDEX
+
+      # @!attribute [rw] index
+      #   @return [Integer]
       attr_accessor :index
 
-      # @return [Message]
+      # @!attribute [rw] message
+      #   @return [Message]
       attr_accessor :message
 
       # @param message [Message]
       # @param index [Integer]
-      def initialize(message:, index: 0)
+      def initialize(message:, index: DEFAULT_INDEX)
         @message = message
         @index = index
       end
@@ -31,7 +36,7 @@ module OmniAI
         deserialize = context&.deserializer(:choice)
         return deserialize.call(data, context:) if deserialize
 
-        index = data["index"]
+        index = data["index"] || DEFAULT_INDEX
         message = Message.deserialize(data["message"] || data["delta"], context:)
 
         new(message:, index:)

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/file.rb

@@ -4,6 +4,8 @@ module OmniAI
   class Chat
     # A file is media that can be sent to many LLMs.
     class File < Media
+      # @!attribute [rw] io
+      #   @return [IO, Pathname, String]
       attr_accessor :io
 
       # @param io [IO, Pathname, String]

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

@@ -38,18 +38,21 @@ module OmniAI
         end
       end
 
-      # @return [Array<Content>, String]
+      # @!attribute [rw] content
+      #   @return [Array<Content>, String]
       attr_accessor :content
 
-      # @return [String]
+      # @!attribute [rw] role
+      #   @return [String]
       attr_accessor :role
 
-      # @return [Array<ToolCall>, nil]
+      # @!attribute [rw] tool_call_list
+      #   @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
@@ -83,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
@@ -101,7 +104,7 @@ 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

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

@@ -2,29 +2,43 @@
 
 module OmniAI
   class Chat
-    # Used when streaming to process chunks of data.
+    # A stream is used to process a series of chunks of data. It converts the following into a combined payload:
+    #
+    #   { "id":"...", "choices": [{ "index": 0,"delta": { "role" :"assistant", "content":"" } }] }
+    #   { "id":"...", "choices": [{ "index": 0,"delta": { "content" :"A" } }] }
+    #   { "id":"...", "choices": [{ "index": 0,"delta": { "content" :"B" } }] }
+    #   ...
+    #
+    # Every
     class Stream
       # @param logger [OmniAI::Client]
-      # @param body [HTTP::Response::Body]
-      # @param context [Context, nil]
-      def initialize(body:, logger: nil, context: nil)
-        @body = body
+      # @param chunks [Enumerable<String>]
+      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 [Hash]
       def stream!(&block)
-        @body.each do |chunk|
+        @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]
@@ -38,18 +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]
-      #
-      # @yield [payload]
-      # @yieldparam payload [OmniAI::Chat::Payload]
-      def process!(type, data, id, &block)
+      def process!(type, data, id, &)
         log(type, data, id)
 
         return if data.eql?("[DONE]")
 
-        block.call(Payload.deserialize(JSON.parse(data), context: @context))
+        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,31 +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::Stream]
+    #
+    # @return [OmniAI::Chat::Response]
     def stream!(response:)
       raise Error, "#{self.class.name}#stream! unstreamable" unless @stream
 
-      self.class::Stream.new(body: 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
@@ -177,7 +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))
+
+      response
     end
 
     # @return [HTTP::Response]

data/lib/omniai/cli.rb

@@ -10,8 +10,6 @@ module OmniAI
   #   cli = OmniAI::CLI.new
   #   cli.parse
   class CLI
-    ChatArgs = Struct.new(:provider, :model, :temperature)
-
     # @param stdin [IO] a stream
     # @param stdout [IO] a stream
     # @param provider [String] a provider

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/tool/property.rb

@@ -58,7 +58,7 @@ module OmniAI
       #   )
       #
       # @param properties [Hash<String, OmniAI::Tool::Property>] required - the properties of the object
-      # @param requird [Array<Symbol>] optional - the required properties
+      # @param required [Array<Symbol>] optional - the required properties
       # @param description [String] optional - a description of the object
       #
       # @return [OmniAI::Tool::Array]

data/lib/omniai/transcribe/transcription.rb

@@ -4,7 +4,17 @@ module OmniAI
   class Transcribe
     # A transcription returned by the API.
     class Transcription
-      attr_accessor :text, :model, :format
+      # @!attribute [rw] text
+      #   @return [String]
+      attr_accessor :text
+
+      # @!attribute [rw] model
+      #   @return [String]
+      attr_accessor :model
+
+      # @!attribute [rw] format
+      #   @return [String]
+      attr_accessor :format
 
       # @param text [String]
       # @param model [String]

data/lib/omniai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OmniAI
-  VERSION = "1.9.5"
+  VERSION = "2.0.0"
 end

data/lib/omniai.rb

@@ -27,6 +27,7 @@ module OmniAI
       @response = response
     end
 
+    # @return [String]
     def inspect
       "#<#{self.class} status=#{@response.status} body=#{@response.body}>"
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: omniai
 version: !ruby/object:Gem::Version
-  version: 1.9.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Kevin Sylvestre
 bindir: exe
 cert_chain: []
-date: 2025-01-30 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
@@ -140,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.3
 specification_version: 4
 summary: A generalized framework for interacting with many AI services
 test_files: []

data/lib/omniai/chat/payload.rb

@@ -1,85 +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)
-        @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 index [Integer]
-      # @return [Choice]
-      def choice(index: 0)
-        @choices[index]
-      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