omniai-openai 2.6.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c5c440743bc36c6ce9b0485ef1aab69627397d77ae7a729877fa15de14610f3
-  data.tar.gz: 7fb943d6ad6ad7a03cad46da3f276e4e816e1d66e96fe05584bd0ec586228d39
+  metadata.gz: d06da3f28613c3f683a2b6ddc712843451726d7c6d14a728d16ab383d6093fc1
+  data.tar.gz: e3f02890b984ef9522f39e0f28e80ee8cbb0b6b058af7232d260964858066b6f
 SHA512:
-  metadata.gz: '09a5264c64c11436a65a158624942030300d0520671716ff9ac32f2a5c5f4903481ef07f277d046c13e89694eb61cc229063bcffcfafd8db2e6a051417840b3b'
-  data.tar.gz: 688b733315e69029a24493c02d44e039445e22c056856f9c3e3748418ecb5b0f98ab86ebb7ad14a6c7ae2095950a6b8d6377e9ccacf7a6d64e28d8675d8fb9f2
+  metadata.gz: 29bb8f139c1337201b695aee14303b0d2ed62b76f140898b068b765bf5112dc589037ec021a2454cf4e2c7113911c643fd5173b8efd7da8f347c8c0525a3db43
+  data.tar.gz: 8d12830098e2d63ad1d4555ee781f1515e9624e1dafc7db90c041832e9fed005c3bfa05b21b6d2b16ed8cff0ed66d2cf87a6ec0009b8aeebe8ce7e2024b3d8a7

data/lib/omniai/openai/chat/choice_serializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides choice serialize / deserialize.
+      module ChoiceSerializer
+        # @param choice [OmniAI::Chat::Choice]
+        # @param context [Context]
+        #
+        # @return [Hash]
+        def self.serialize(choice, context:)
+          choice.message.serialize(context:)
+        end
+
+        # @param data [Hash]
+        # @param context [Context]
+        #
+        # @return [OmniAI::Chat::Choice]
+        def self.deserialize(data, context:)
+          message = OmniAI::Chat::Message.deserialize(data, context:)
+          OmniAI::Chat::Choice.new(message:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/content_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides content serialize / deserialize.
+      module ContentSerializer
+        # @param data [Hash]
+        # @param context [Context]
+        #
+        # @return [OmniAI::Chat::Text, OmniAI::Chat::ToolCall]
+        def self.deserialize(data, context:)
+          case data["type"]
+          when /(input|output)_text/ then OmniAI::Chat::Text.deserialize(data, context:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/file_serializer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides file serialize / deserialize.
+      module FileSerializer
+        # @param file [OmniAI::Chat::File]
+        # @param direction [String] "input" or "output"
+        #
+        # @return [Hash]
+        def self.serialize(file, direction:, **)
+          type = file.image? ? "image" : "file"
+
+          {
+            type: "#{direction}_#{type}",
+            "#{type}_data": file.data,
+            filename: file.filename,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/message_serializer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides message serialize / deserialize.
+      module MessageSerializer
+        # @param message [OmniAI::Chat::Message]
+        # @param context [OmniAI::Context]
+        #
+        # @return [Hash]
+        def self.serialize(message, context:)
+          if message.tool?
+            serialize_for_tool_call(message, context:)
+          else
+            serialize_for_content(message, context:)
+          end
+        end
+
+        # @param message [OmniAI::Chat::Message]
+        # @param context [OmniAI::Context]
+        #
+        # @return [Hash]
+        def self.serialize_for_tool_call(message, context:)
+          tool_call_list = message.tool_call_list
+          tool_call = tool_call_list[0]
+          tool_call.serialize(context:)
+        end
+
+        # @param message [OmniAI::Chat::Message]
+        # @param context [OmniAI::Context]
+        #
+        # @return [Hash]
+        def self.serialize_for_content(message, context:)
+          role = message.role
+          direction = message.direction
+          parts = arrayify(message.content)
+
+          content = parts.map do |part|
+            case part
+            when String then { type: "#{direction}_text", text: part }
+            else part.serialize(context:, direction:)
+            end
+          end
+
+          { role:, content: }
+        end
+
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Message]
+        def self.deserialize(data, context:)
+          case data["type"]
+          when "message" then deserialize_for_content(data, context:)
+          when "function_call" then deserialize_for_tool_call(data, context:)
+          end
+        end
+
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Message]
+        def self.deserialize_for_content(data, context:)
+          role = data["role"]
+          content = data["content"].map do |content|
+            OmniAI::Chat::Content.deserialize(content, context:)
+          end
+          OmniAI::Chat::Message.new(role:, content:)
+        end
+
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Message]
+        def self.deserialize_for_tool_call(data, context:)
+          entry = OmniAI::Chat::ToolCall.deserialize(data, context:)
+          tool_call_list = OmniAI::Chat::ToolCallList.new(entries: [entry])
+          OmniAI::Chat::Message.new(role: OmniAI::Chat::Role::TOOL, content: nil, tool_call_list:)
+        end
+
+        # @param content [Object]
+        #
+        # @return [Array<Object>]
+        def self.arrayify(content)
+          return [] if content.nil?
+
+          content.is_a?(Array) ? content : [content]
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/response_serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides response serialize / deserialize.
+      module ResponseSerializer
+        # @param response [OmniAI::Chat::Response]
+        # @param context [OmniAI::Context]
+        #
+        # @return [Hash]
+        def self.serialize(response, context:)
+          usage = response.usage.serialize(context:)
+          output = response.choices.serialize(context:)
+
+          {
+            usage:,
+            output:,
+          }
+        end
+
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Response]
+        def self.deserialize(data, context:)
+          usage = OmniAI::Chat::Usage.deserialize(data["usage"], context:) if data["usage"]
+          choices = data["output"].map { |choice_data| OmniAI::Chat::Choice.deserialize(choice_data, context:) }
+
+          OmniAI::Chat::Response.new(data:, choices:, usage:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/stream.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # For each chunk yield the text delta. Parse the final content into a response.
+      class Stream < OmniAI::Chat::Stream
+        # @yield [delta]
+        # @yieldparam delta [OmniAI::Chat::Delta]
+        #
+        # @return [Hash]
+        def stream!(&block)
+          response = {}
+
+          @chunks.each do |chunk|
+            parser.feed(chunk) do |type, data, _id|
+              case type
+              when /response\.(.*)_text\.delta/
+                block.call(OmniAI::Chat::Delta.new(text: JSON.parse(data)["delta"]))
+              when "response.completed"
+                response = JSON.parse(data)["response"]
+              end
+            end
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/text_serializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides text serialize / deserialize.
+      module TextSerializer
+        # @param text [OmniAI::Chat::Text]
+        # @param direction [String] "input" or "output"
+        #
+        # @return [Hash]
+        def self.serialize(text, direction:, **)
+          raise text.inspect if direction.nil?
+
+          { type: "#{direction}_text", text: text.text }
+        end
+
+        # @param data [Hash]
+        #
+        # @return [OmniAI::Chat::Text]
+        def self.deserialize(data, *)
+          OmniAI::Chat::Text.new(data["text"])
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/tool_call_message_serializer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides tool-call message serialize / deserialize.
+      module ToolCallMessageSerializer
+        # @param message [OmniAI::Chat::ToolCallMessage]
+        #
+        # @return [Hash]
+        def self.serialize(message, *)
+          {
+            type: "function_call_output",
+            call_id: message.tool_call_id,
+            output: JSON.generate(message.content),
+          }
+        end
+
+        # @param data [Hash]
+        #
+        # @return [OmniAI::Chat::ToolCallMessage]
+        def self.deserialize(data, *)
+          content = data["content"]
+          tool_call_id = data["call_id"]
+          OmniAI::Chat::ToolCallMessage.new(content:, tool_call_id:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/tool_call_result_serializer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides tool-call response serialize / deserialize.
+      module ToolCallResultSerializer
+        # @param tool_call_result [OmniAI::Chat::ToolCallResult]
+        #
+        # @return [Hash]
+        def self.serialize(tool_call_result, *)
+          {
+            type: "function_call_output",
+            call_id: tool_call_result.tool_call_id,
+            output: tool_call_result.text,
+          }
+        end
+
+        # @param data [Hash]
+        #
+        # @return [OmniAI::Chat::ToolCallResult]
+        def self.deserialize(data, *)
+          tool_call_id = data["call_id"]
+          content = data["output"]
+
+          OmniAI::Chat::ToolCallResult.new(content:, tool_call_id:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/tool_call_serializer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides tool-call serialize / deserialize.
+      module ToolCallSerializer
+        # @param tool_call [OmniAI::Chat::ToolCall]
+        # @param context [OmniAI::Context]
+        #
+        # @return [Hash]
+        def self.serialize(tool_call, context:)
+          function = tool_call.function.serialize(context:)
+
+          {
+            call_id: tool_call.id,
+            type: "function_call",
+          }.merge(function)
+        end
+
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::ToolCall]
+        def self.deserialize(data, context:)
+          function = OmniAI::Chat::Function.deserialize(data, context:)
+          OmniAI::Chat::ToolCall.new(id: data["id"], function:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/tool_serializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides text serialize / deserialize.
+      module ToolSerializer
+        # @param tool [OmniAI::Tool]
+        # @return [Hash]
+        def self.serialize(tool, *)
+          {
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters.is_a?(Schema::Object) ? tool.parameters.serialize : tool.parameters,
+            strict: true,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat/url_serializer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides media serialize / deserialize.
+      module URLSerializer
+        # @param url [OmniAI::Chat::URL]
+        # @param direction [String] "input" or "output"
+        #
+        # @return [Hash]
+        def self.serialize(url, direction:, **)
+          type = url.image? ? "image" : "file"
+
+          {
+            type: "#{direction}_#{type}",
+            "#{type}_url": url.uri,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat.rb

@@ -12,8 +12,6 @@ module OmniAI
     #   end
     #   completion.choice.message.content # '...'
     class Chat < OmniAI::Chat
-      DEFAULT_STREAM_OPTIONS = { include_usage: ENV.fetch("OMNIAI_STREAM_USAGE", "on").eql?("on") }.freeze
-
       module ResponseFormat
         TEXT_TYPE = "text"
         JSON_TYPE = "json_object"
@@ -53,23 +51,71 @@ module OmniAI
         O3 = "o3"
       end
 
-      DEFAULT_MODEL = Model::GPT_4_1
+      DEFAULT_MODEL = Model::GPT_5_1
+
+      # @return [Context]
+      CONTEXT = Context.build do |context|
+        context.serializers[:choice] = ChoiceSerializer.method(:serialize)
+        context.deserializers[:choice] = ChoiceSerializer.method(:deserialize)
+        context.serializers[:message] = MessageSerializer.method(:serialize)
+        context.deserializers[:message] = MessageSerializer.method(:deserialize)
+        context.serializers[:text] = TextSerializer.method(:serialize)
+        context.deserializers[:text] = TextSerializer.method(:deserialize)
+        context.serializers[:response] = ResponseSerializer.method(:serialize)
+        context.deserializers[:response] = ResponseSerializer.method(:deserialize)
+        context.deserializers[:content] = ContentSerializer.method(:deserialize)
+        context.serializers[:file] = FileSerializer.method(:serialize)
+        context.serializers[:url] = URLSerializer.method(:serialize)
+        context.serializers[:tool] = ToolSerializer.method(:serialize)
+        context.serializers[:tool_call] = ToolCallSerializer.method(:serialize)
+        context.deserializers[:tool_call] = ToolCallSerializer.method(:deserialize)
+        context.serializers[:tool_call_result] = ToolCallResultSerializer.method(:serialize)
+        context.deserializers[:tool_call_result] = ToolCallResultSerializer.method(:deserialize)
+        context.serializers[:tool_call_message] = ToolCallMessageSerializer.method(:serialize)
+        context.deserializers[:tool_call_message] = ToolCallMessageSerializer.method(:deserialize)
+      end
 
     protected
 
+      # @return [Context]
+      def context
+        CONTEXT
+      end
+
+      # @return [Array<Hash>]
+      def input
+        @prompt
+          .messages
+          .reject(&:system?)
+          .map { |message| message.serialize(context:) }
+      end
+
+      # @return [String, nil]
+      def instructions
+        parts = @prompt
+          .messages
+          .filter(&:system?)
+          .filter(&:text?)
+          .map(&:text)
+
+        return if parts.empty?
+
+        parts.join("\n\n")
+      end
+
       # @return [Float, nil]
       def temperature
         return if @temperature.nil?
 
-        unsupported_models = [
-          Model::O1_MINI, Model::O3_MINI, Model::O1,
-          Model::GPT_5_1, Model::GPT_5, Model::GPT_5_MINI, Model::GPT_5_NANO,
-        ]
-
-        if unsupported_models.any? { |model| model.eql?(@model) }
-          logger&.warn("unsupported temperature=#{@temperature} for model=#{@model}")
-          return
-        end
+        return if [
+          Model::GPT_5,
+          Model::GPT_5_MINI,
+          Model::GPT_5_NANO,
+          Model::GPT_5_1,
+          Model::O1_MINI,
+          Model::O1,
+          Model::O3_MINI,
+        ].include?(@model)
 
         @temperature
       end
@@ -77,71 +123,61 @@ module OmniAI
       # @return [Hash]
       def payload
         OmniAI::OpenAI.config.chat_options.merge({
-          messages: @prompt.serialize,
-          model: @model,
-          response_format:,
+          instructions:,
+          input:,
+          model: @model || DEFAULT_MODEL,
           stream: stream? || nil,
-          stream_options: (DEFAULT_STREAM_OPTIONS if stream?),
           temperature:,
-          tools: (@tools.map(&:serialize) if @tools&.any?),
-          reasoning_effort: reasoning_effort_payload,
-          verbosity: verbosity_payload,
-        }.merge(@kwargs || {})).compact
+          tools:,
+          text:,
+          reasoning:,
+        }).compact
+      end
+
+      # @return [Array<Hash>]
+      def tools
+        return unless @tools&.any?
+
+        @tools.map { |tool| tool.serialize(context:) }
       end
 
       # @return [String]
       def path
-        "#{@client.api_prefix}/#{OmniAI::OpenAI::Client::VERSION}/chat/completions"
+        "#{@client.api_prefix}/#{OmniAI::OpenAI::Client::VERSION}/responses"
+      end
+
+      # @return [Hash]
+      def text
+        options = @options.fetch(:text, {}).merge(format:).compact
+        options unless options.empty?
+      end
+
+      # @return [Hash]
+      def reasoning
+        options = @options.fetch(:reasoning, {})
+        options unless options.empty?
       end
 
       # @raise [ArgumentError]
       #
       # @return [Hash, nil]
-      def response_format
+      def format
         return if @format.nil?
 
         case @format
         when :text then { type: ResponseFormat::TEXT_TYPE }
         when :json then { type: ResponseFormat::JSON_TYPE }
-        when OmniAI::Schema::Format then { type: ResponseFormat::SCHEMA_TYPE, json_schema: @format.serialize }
+        when OmniAI::Schema::Format
+          @format.serialize.merge({ type: ResponseFormat::SCHEMA_TYPE, strict: true })
         else raise ArgumentError, "unknown format=#{@format}"
         end
       end
 
-      # @raise [ArgumentError]
-      #
-      # @return [String, nil]
-      def reasoning_effort_payload
-        return if @reasoning.nil?
-
-        effort = @reasoning[:effort] || @reasoning["effort"]
-        return if effort.nil?
-
-        valid_efforts = [ReasoningEffort::NONE, ReasoningEffort::LOW, ReasoningEffort::MEDIUM, ReasoningEffort::HIGH]
-        unless valid_efforts.include?(effort)
-          raise ArgumentError,
-            "reasoning effort must be one of #{valid_efforts.join(', ')}"
-        end
-
-        effort
-      end
-
-      # @raise [ArgumentError]
-      #
-      # @return [String, nil]
-      def verbosity_payload
-        return if @verbosity.nil?
-
-        text = @verbosity[:text] || @verbosity["text"]
-        return if text.nil?
-
-        valid_text_levels = [VerbosityText::LOW, VerbosityText::MEDIUM, VerbosityText::HIGH]
-        unless valid_text_levels.include?(text)
-          raise ArgumentError,
-            "verbosity text must be one of #{valid_text_levels.join(', ')}"
+      # @return [Array<ToolCallMessage>]
+      def build_tool_call_messages(tool_call_list)
+        tool_call_list.map do |tool_call|
+          ToolCallMessage.new(tool_call_id: tool_call.id, content: execute_tool_call(tool_call))
         end
-
-        text
       end
     end
   end

data/lib/omniai/openai/client.rb

@@ -71,22 +71,19 @@ module OmniAI
 
       # @raise [OmniAI::Error]
       #
-      # @param messages [String] optional
-      # @param model [String] optional
-      # @param format [Symbol] optional :text or :json
+      # @param prompt [String, OmniAI::Chat::Prompt, nil] optional
+      # @param model [String, nil] optional
+      # @param format [Symbol, OmniAI::Schema::Format, nil] optional (e.g. `:text`, `:json`, `OmniAI::Schema.format(...)`)
       # @param temperature [Float, nil] optional
       # @param stream [Proc, nil] optional
       # @param tools [Array<OmniAI::Tool>, nil] optional
-      # @param reasoning [Hash, nil] optional reasoning configuration
-      # @param verbosity [Hash, nil] optional verbosity configuration
       #
       # @yield [prompt]
       # @yieldparam prompt [OmniAI::Chat::Prompt]
       #
       # @return [OmniAI::Chat::Completion]
-      def chat(messages = nil, model: Chat::DEFAULT_MODEL, temperature: nil, format: nil, stream: nil, tools: nil,
-        reasoning: nil, verbosity: nil, &)
-        Chat.process!(messages, model:, temperature:, format:, stream:, tools:, reasoning:, verbosity:, client: self, &)
+      def chat(prompt = nil, model: Chat::DEFAULT_MODEL, temperature: nil, format: nil, stream: nil, tools: nil, **, &)
+        Chat.process!(prompt, model:, temperature:, format:, stream:, tools:, client: self, **, &)
       end
 
       # @raise [OmniAI::Error]

data/lib/omniai/openai/version.rb

@@ -2,6 +2,6 @@
 
 module OmniAI
   module OpenAI
-    VERSION = "2.6.5"
+    VERSION = "3.0.0"
   end
 end

data/lib/omniai/openai.rb

@@ -7,6 +7,7 @@ require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.push_dir(__dir__, namespace: OmniAI)
 loader.inflector.inflect "openai" => "OpenAI"
+loader.inflector.inflect "url_serializer" => "URLSerializer"
 loader.setup
 
 module OmniAI

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omniai-openai
 version: !ruby/object:Gem::Version
-  version: 2.6.5
+  version: 3.0.0
 platform: ruby
 authors:
 - Kevin Sylvestre
@@ -29,14 +29,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -62,6 +76,18 @@ files:
 - README.md
 - lib/omniai/openai.rb
 - lib/omniai/openai/chat.rb
+- lib/omniai/openai/chat/choice_serializer.rb
+- lib/omniai/openai/chat/content_serializer.rb
+- lib/omniai/openai/chat/file_serializer.rb
+- lib/omniai/openai/chat/message_serializer.rb
+- lib/omniai/openai/chat/response_serializer.rb
+- lib/omniai/openai/chat/stream.rb
+- lib/omniai/openai/chat/text_serializer.rb
+- lib/omniai/openai/chat/tool_call_message_serializer.rb
+- lib/omniai/openai/chat/tool_call_result_serializer.rb
+- lib/omniai/openai/chat/tool_call_serializer.rb
+- lib/omniai/openai/chat/tool_serializer.rb
+- lib/omniai/openai/chat/url_serializer.rb
 - lib/omniai/openai/client.rb
 - lib/omniai/openai/config.rb
 - lib/omniai/openai/embed.rb