omniai-google 3.3.3 → 3.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1c2cc91a787673b5e875ee28c1d5e173b129e7eacb37ece64495bb25734ceba
-  data.tar.gz: fb15b6963dd2f711248b853a3c4782d0b9762fcc05777d6f4ac90fe719ab34a6
+  metadata.gz: 8ed53a642ea244879948b2831fb9f9dfb301eb7a1cedfff39e26131e6a6bb36e
+  data.tar.gz: abe713af3afe2f678e515ea23fd1cc1cc8b6ab0f328d77936e3a3990d3cd06fa
 SHA512:
-  metadata.gz: 1f4ee8e419634378e0ef36954075b8ba52e682c75942a8bfeb6ad33b9f4d503d157bc294356eb33d4b174a44384956b9fd96fc09ff8824b48bad0f8cc881cdc2
-  data.tar.gz: cd252893230465bd90742145a03c202ebe7b74b887d050d65e51c62f671913d74d03e4d44e7846582cb4b108b240b02ecddd31a56838a028e3bee57ae0d28812
+  metadata.gz: 154befd060662f97e6a3b8fdb9a2ba55879f3226f89a8f4c539572c7064c973599e32892567af9b91c173ef42da3995b0d2a237765892a735c27227b59b4c1ec
+  data.tar.gz: 4d4992ccb4a94e074e2ed185afadebb7dfedb1b44c08ed68485b243876f70b6a6dce4242424538545962bf4992c3176b6d26398a998887b09dd0f5ac45b5cd01

data/README.md

@@ -118,6 +118,36 @@ end
 client.chat('Be poetic.', stream:)
 ```
 
+#### Extended Thinking
+
+Google Gemini 2.0+ models support extended thinking, which shows the model's reasoning process.
+
+```ruby
+# Enable thinking
+response = client.chat("What is 25 * 25?", model: "gemini-2.5-pro-preview-05-06", thinking: true)
+```
+
+#### Accessing Thinking Content
+
+```ruby
+response.choices.first.message.contents.each do |content|
+  case content
+  when OmniAI::Chat::Thinking
+    puts "Thinking: #{content.thinking}"
+  when OmniAI::Chat::Text
+    puts "Response: #{content.text}"
+  end
+end
+```
+
+#### Streaming with Thinking
+
+```ruby
+client.chat("What are the prime factors of 1234567?", model: "gemini-2.5-pro-preview-05-06", thinking: true, stream: $stdout)
+```
+
+[Google API Reference `thinking`](https://ai.google.dev/gemini-api/docs/thinking)
+
 ### Upload
 
 An upload is especially useful when processing audio / image / video / text files. To use:

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

@@ -7,9 +7,10 @@ module OmniAI
       module ContentSerializer
         # @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
+          when data["thought"] then OmniAI::Chat::Thinking.deserialize(data, context:)
           when data["text"] then data["text"]
           when data["functionCall"] then OmniAI::Chat::ToolCall.deserialize(data, context:)
           end

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

@@ -27,6 +27,7 @@ module OmniAI
           role = data["role"]
           parts = arrayify(data["parts"]).map do |part|
             case
+            when part["thought"] then OmniAI::Chat::Thinking.deserialize(part, context:)
             when part["text"] then OmniAI::Chat::Text.deserialize(part, context:)
             when part["functionCall"] then OmniAI::Chat::ToolCall.deserialize(part, context:)
             when part["functionResponse"] then OmniAI::Chat::ToolCallResult.deserialize(part, context:)

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

@@ -57,7 +57,12 @@ module OmniAI
           return unless candidate["content"]
 
           candidate["content"]["parts"].each do |part|
-            block&.call(OmniAI::Chat::Delta.new(text: part["text"])) if part["text"]
+            if part["thought"]
+              # Google uses thought: true as a flag, content is in text
+              block&.call(OmniAI::Chat::Delta.new(thinking: part["text"]))
+            elsif part["text"]
+              block&.call(OmniAI::Chat::Delta.new(text: part["text"]))
+            end
           end
 
           merge_candidate!(candidate:, index:)
@@ -82,8 +87,12 @@ module OmniAI
         # @param part [Hash]
         # @param into [Hash]
         def merge_part!(part:, candidate:)
-          if candidate["content"]["parts"][-1]&.key?("text") && part["text"]
-            candidate["content"]["parts"][-1]["text"] += part["text"]
+          last_part = candidate["content"]["parts"][-1]
+
+          if last_part&.key?("text") && part["text"]
+            last_part["text"] += part["text"]
+          elsif last_part&.key?("thought") && part["thought"]
+            last_part["thought"] += part["thought"]
           else
             candidate["content"]["parts"] << part
           end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Google
+    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
+          # Google uses "thought: true" as a flag, with content in "text"
+          OmniAI::Chat::Thinking.new(data["text"])
+        end
+
+        # @param thinking [OmniAI::Chat::Thinking]
+        # @param context [Context]
+        #
+        # @return [Hash]
+        def self.serialize(thinking, context: nil) # rubocop:disable Lint/UnusedMethodArgument
+          { thought: true, text: thinking.thinking }
+        end
+      end
+    end
+  end
+end

data/lib/omniai/google/chat.rb

@@ -65,6 +65,9 @@ module OmniAI
         context.deserializers[:content] = ContentSerializer.method(:deserialize)
 
         context.serializers[:tool] = ToolSerializer.method(:serialize)
+
+        context.serializers[:thinking] = ThinkingSerializer.method(:serialize)
+        context.deserializers[:thinking] = ThinkingSerializer.method(:deserialize)
       end
 
     protected
@@ -129,6 +132,7 @@ module OmniAI
           end
 
         data[:temperature] = @temperature if @temperature
+        data[:thinkingConfig] = thinking_config if thinking_config
 
         data = data.compact
         data unless data.empty?
@@ -144,6 +148,19 @@ module OmniAI
         stream? ? "streamGenerateContent" : "generateContent"
       end
 
+      # Translates unified thinking option to Google's thinkingConfig format.
+      # Example: `thinking: true` becomes `{ includeThoughts: true }`
+      # @return [Hash, nil]
+      def thinking_config
+        thinking = @options[:thinking]
+        return unless thinking
+
+        case thinking
+        when true then { includeThoughts: true }
+        when Hash then { includeThoughts: true }.merge(thinking)
+        end
+      end
+
       # @return [Array<Message>]
       def build_tool_call_messages(tool_call_list)
         content = tool_call_list.map do |tool_call|

data/lib/omniai/google/client.rb

@@ -67,8 +67,9 @@ module OmniAI
       # @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, &)
-        Chat.process!(messages, model:, temperature:, format:, stream:, tools:, client: self, &)
+      def chat(messages = nil, model: Chat::DEFAULT_MODEL, temperature: nil, format: nil, stream: nil, tools: nil,
+        **, &)
+        Chat.process!(messages, model:, temperature:, format:, stream:, tools:, client: self, **, &)
       end
 
       # @param io [File, String] required - a file or URL

data/lib/omniai/google/version.rb

@@ -2,6 +2,6 @@
 
 module OmniAI
   module Google
-    VERSION = "3.3.3"
+    VERSION = "3.4.3"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omniai-google
 version: !ruby/object:Gem::Version
-  version: 3.3.3
+  version: 3.4.3
 platform: ruby
 authors:
 - Kevin Sylvestre
@@ -113,6 +113,7 @@ files:
 - lib/omniai/google/chat/response_serializer.rb
 - lib/omniai/google/chat/stream.rb
 - lib/omniai/google/chat/text_serializer.rb
+- lib/omniai/google/chat/thinking_serializer.rb
 - lib/omniai/google/chat/tool_call_result_serializer.rb
 - lib/omniai/google/chat/tool_call_serializer.rb
 - lib/omniai/google/chat/tool_serializer.rb