omniai-openai 3.0.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf857f3e19a92c38074533033d27f0c72c38b8b241821964c6a5afdd43c9c0ea
-  data.tar.gz: 99bf66f3fa309e921eb585ad4462090456d5eec6f55886695fd5214a78825ec6
+  metadata.gz: 6c84d3becf5f93c58078e182e156861262bafc112e59ccb2c67d6ff08d0bb399
+  data.tar.gz: 31cb3de11d80088728a2f80193903f2740db4fd13c058b72db780561b25fc317
 SHA512:
-  metadata.gz: e5661128cc6388ae20b5eebdcac7eb31d7760fac041cd153ba8ceefa5f9c7461b9834f2c425d712ff15f87ce5f20ad83cf07187be99d7d22a999e56a49081eb4
-  data.tar.gz: 9d3a37d7108178cb19dfe8573888eee036c4e635759f0c7b3ed6932d84dad16b1ce19cfbd3db36947587bf5e82d3d51ba6ec36736b97a120966ee451d8930d1a
+  metadata.gz: 8b789a962479764a1de021ee658cf27d82550e8d2699777bf7cc8294ffe099c9748ec4411d2296ece309e3dbd039685d0d2da0ed1f4380c573180fe042a7aa94
+  data.tar.gz: 180e1daaebcddb697f9e63d2b41e2adcd25a3e22e2845a184d43669497d415e350afeced8aa8cc99ec55c19dd67233685d034e138e80dcc0a26b7a089d216ca0

data/README.md

@@ -146,6 +146,44 @@ JSON.parse(completion.content) # { "name": "Ringo" }
 
 > When using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message.
 
+#### Reasoning
+
+OpenAI o1 and o3 models support reasoning, which provides a summary of the model's thought process.
+
+```ruby
+# Enable reasoning with unified thinking API
+response = client.chat("What is 25 * 25?", model: "o3-mini", thinking: true)
+
+# Or use OpenAI-specific reasoning options
+response = client.chat("What is 25 * 25?", model: "o3-mini", reasoning: { effort: "high", summary: "auto" })
+```
+
+**Reasoning Effort Levels:**
+- `low` - Minimal reasoning
+- `medium` - Balanced reasoning
+- `high` - Maximum reasoning effort
+
+#### Accessing Reasoning Content
+
+```ruby
+response.choices.first.message.contents.each do |content|
+  case content
+  when OmniAI::Chat::Thinking
+    puts "Reasoning: #{content.thinking}"
+  when OmniAI::Chat::Text
+    puts "Response: #{content.text}"
+  end
+end
+```
+
+#### Streaming with Reasoning
+
+```ruby
+client.chat("What are the prime factors of 1234567?", model: "o3-mini", thinking: true, stream: $stdout)
+```
+
+[OpenAI API Reference `reasoning`](https://platform.openai.com/docs/guides/reasoning)
+
 ### Transcribe
 
 A transcription is generated by passing in a path to a file:

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

@@ -8,10 +8,11 @@ module OmniAI
         # @param data [Hash]
         # @param context [Context]
         #
-        # @return [OmniAI::Chat::Text, OmniAI::Chat::ToolCall]
+        # @return [OmniAI::Chat::Text, OmniAI::Chat::Thinking, OmniAI::Chat::ToolCall]
         def self.deserialize(data, context:)
           case data["type"]
           when /(input|output)_text/ then OmniAI::Chat::Text.deserialize(data, context:)
+          when "reasoning" then OmniAI::Chat::Thinking.deserialize(data, context:)
           end
         end
       end

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

@@ -30,11 +30,14 @@ module OmniAI
         # @param message [OmniAI::Chat::Message]
         # @param context [OmniAI::Context]
         #
-        # @return [Hash]
+        # @return [Hash, nil]
         def self.serialize_for_content(message, context:)
           role = message.role
           direction = message.direction
-          parts = arrayify(message.content)
+          # Filter out thinking content - OpenAI doesn't accept it in input messages
+          parts = arrayify(message.content).reject { |part| part.is_a?(OmniAI::Chat::Thinking) }
+
+          return if parts.empty?
 
           content = parts.map do |part|
             case part
@@ -54,9 +57,19 @@ module OmniAI
           case data["type"]
           when "message" then deserialize_for_content(data, context:)
           when "function_call" then deserialize_for_tool_call(data, context:)
+          when "reasoning" then deserialize_for_reasoning(data, context:)
           end
         end
 
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Message]
+        def self.deserialize_for_reasoning(data, context:)
+          thinking = OmniAI::Chat::Thinking.deserialize(data, context:)
+          OmniAI::Chat::Message.new(role: OmniAI::Chat::Role::ASSISTANT, content: [thinking])
+        end
+
         # @param data [Hash]
         # @param context [OmniAI::Context]
         #

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

@@ -25,7 +25,7 @@ module OmniAI
         # @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:) }
+          choices = data["output"].filter_map { |choice_data| OmniAI::Chat::Choice.deserialize(choice_data, context:) }
 
           OmniAI::Chat::Response.new(data:, choices:, usage:)
         end

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

@@ -13,10 +13,12 @@ module OmniAI
           response = {}
 
           @chunks.each do |chunk|
-            parser.feed(chunk) do |type, data, _id|
+            parser.feed(chunk.b) do |type, data, _id|
               case type
-              when /response\.(.*)_text\.delta/
+              when "response.output_text.delta"
                 block.call(OmniAI::Chat::Delta.new(text: JSON.parse(data)["delta"]))
+              when "response.reasoning_summary_text.delta"
+                block.call(OmniAI::Chat::Delta.new(thinking: JSON.parse(data)["delta"]))
               when "response.completed"
                 response = JSON.parse(data)["response"]
               end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Chat
+      # Overrides thinking serialize / deserialize.
+      module ThinkingSerializer
+        # @param data [Hash]
+        # @param context [Context]
+        #
+        # @return [OmniAI::Chat::Thinking]
+        def self.deserialize(data, context: nil) # rubocop:disable Lint/UnusedMethodArgument
+          summary = data["summary"]
+
+          thinking = case summary
+                     when Array
+                       summary.filter_map { |item| item["text"] if item["type"] == "summary_text" }.join("\n")
+                     when String
+                       summary
+                     else
+                       data["thinking"]
+                     end
+
+          OmniAI::Chat::Thinking.new(thinking)
+        end
+
+        # @param thinking [OmniAI::Chat::Thinking]
+        # @param context [Context]
+        #
+        # @return [Hash]
+        def self.serialize(thinking, context: nil) # rubocop:disable Lint/UnusedMethodArgument
+          { type: "reasoning", summary: thinking.thinking }
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/chat.rb

@@ -74,6 +74,8 @@ module OmniAI
         context.deserializers[:tool_call_result] = ToolCallResultSerializer.method(:deserialize)
         context.serializers[:tool_call_message] = ToolCallMessageSerializer.method(:serialize)
         context.deserializers[:tool_call_message] = ToolCallMessageSerializer.method(:deserialize)
+        context.serializers[:thinking] = ThinkingSerializer.method(:serialize)
+        context.deserializers[:thinking] = ThinkingSerializer.method(:deserialize)
       end
 
     protected
@@ -88,7 +90,7 @@ module OmniAI
         @prompt
           .messages
           .reject(&:system?)
-          .map { |message| message.serialize(context:) }
+          .filter_map { |message| message.serialize(context:) }
       end
 
       # @return [String, nil]
@@ -155,9 +157,24 @@ module OmniAI
       end
 
       # @return [Hash]
+      # Accepts unified `thinking:` option and translates to OpenAI's `reasoning:` format.
+      # Example: `thinking: { effort: "high" }` becomes `reasoning: { effort: "high", summary: "auto" }`
       def reasoning
-        options = @options.fetch(:reasoning, {})
-        options unless options.empty?
+        # Support both native `reasoning:` and unified `thinking:` options
+        options = @options[:reasoning] || translate_thinking_to_reasoning
+        options unless options.nil? || options.empty?
+      end
+
+      # Translates unified thinking option to OpenAI reasoning format
+      # @return [Hash, nil]
+      def translate_thinking_to_reasoning
+        thinking = @options[:thinking]
+        return unless thinking
+
+        case thinking
+        when true then { effort: ReasoningEffort::HIGH, summary: "auto" }
+        when Hash then { summary: "auto" }.merge(thinking)
+        end
       end
 
       # @raise [ArgumentError]

data/lib/omniai/openai/version.rb

@@ -2,6 +2,6 @@
 
 module OmniAI
   module OpenAI
-    VERSION = "3.0.1"
+    VERSION = "3.1.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omniai-openai
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.2
 platform: ruby
 authors:
 - Kevin Sylvestre
@@ -83,6 +83,7 @@ files:
 - lib/omniai/openai/chat/response_serializer.rb
 - lib/omniai/openai/chat/stream.rb
 - lib/omniai/openai/chat/text_serializer.rb
+- lib/omniai/openai/chat/thinking_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