omniai-anthropic 3.0.1 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 122d1e2eb26278fa1fe10129363873f18143d8997ec248246919b1a5291c6596
-  data.tar.gz: '0268f4f9c74dfb2705169d31d1ac870793d1e3b14316c897c5ee5def2aca2da9'
+  metadata.gz: 5077178a43cec44b1c90e0fc272ee5b1e6e8b025387ed6bb71c2238514187631
+  data.tar.gz: 416834202514d4acfa5e742a8dba508f8aecd9042a5cc5ecff16d22366406cd7
 SHA512:
-  metadata.gz: e217d230e744747c151f844b5de5f1aaf080f99bf9fdb688eb3687ab38571488e9412dea9d7bd79bb884b1bee548ed6cb9e87a45a0448db042fbe770e03841a5
-  data.tar.gz: efb235cbc97a968a4f915dbfe6b48fda1e34a4aa47771ee2f50831af33534648faa475dc02aca0f2147ee9a3e286ccdb336528c26ed2cc53c029439ac4e8517d
+  metadata.gz: bab092c2f66f0ac792f09574974afdaa0f8e6a575482661c168374089aa5380202feeaaa617a2259fd81718f738b6c68c0280bba438ba35de7ae66d154f0a555
+  data.tar.gz: 5e4b8e0d4db1e9769031d8c11e11eedd4d6ad4ff14c6f06d48ae9271138cbcd187ebf379ad9059907fdf5f92c79004f6973522bc58561ac0b1fc1c456d70e3c2

data/README.md

@@ -130,3 +130,43 @@ completion = client.chat(tools: [computer]) do |prompt|
   prompt.user('Please signup for reddit')
 end
 ```
+
+### Extended Thinking
+
+Extended thinking allows Claude to show its reasoning process. This is useful for complex problems where you want to see the model's thought process.
+
+```ruby
+# Enable with default budget (10,000 tokens)
+response = client.chat("What is 25 * 25?", model: "claude-sonnet-4-20250514", thinking: true)
+
+# Or specify a custom budget
+response = client.chat("Solve this complex problem...", model: "claude-sonnet-4-20250514", thinking: { budget_tokens: 20_000 })
+```
+
+When thinking is enabled:
+- Temperature is automatically set to 1 (required by Anthropic)
+- `max_tokens` is automatically adjusted to be greater than `budget_tokens`
+
+#### Accessing Thinking Content
+
+```ruby
+response.choices.first.message.contents.each do |content|
+  case content
+  when OmniAI::Chat::Thinking
+    puts "Thinking: #{content.thinking}"
+    puts "Signature: #{content.metadata[:signature]}" # Anthropic includes a signature
+  when OmniAI::Chat::Text
+    puts "Response: #{content.text}"
+  end
+end
+```
+
+#### Streaming with Thinking
+
+```ruby
+client.chat("What are the prime factors of 1234567?", model: "claude-sonnet-4-20250514", thinking: true, stream: $stdout)
+```
+
+The thinking content will stream first, followed by the response.
+
+[Anthropic API Reference `thinking`](https://docs.anthropic.com/en/docs/build-with-claude/thinking)

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

@@ -7,10 +7,11 @@ module OmniAI
       module ContentSerializer
         # @param data [Hash]
         # @param context [Context]
-        # @return [OmniAI::Chat::Text, OmniAI::Chat::ToolCall]
+        # @return [OmniAI::Chat::Text, OmniAI::Chat::ToolCall, OmniAI::Chat::Thinking]
         def self.deserialize(data, context:)
           case data["type"]
           when "text" then OmniAI::Chat::Text.deserialize(data, context:)
+          when "thinking" then OmniAI::Chat::Thinking.deserialize(data, context:)
           when "tool_use" then OmniAI::Chat::ToolCall.deserialize(data, context:)
           end
         end

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

@@ -11,7 +11,7 @@ module OmniAI
         # @return [Hash]
         def self.serialize(response, context:)
           usage = response.usage.serialize(context:)
-          choice = response.choice.serialize(context:)
+          choice = response.choices.first.serialize(context:)
 
           choice.merge({ usage: })
         end

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

@@ -17,11 +17,14 @@ module OmniAI
         module ContentBlockType
           TEXT = "text"
           TOOL_USE = "tool_use"
+          THINKING = "thinking"
         end
 
         module ContentBlockDeltaType
           TEXT_DELTA = "text_delta"
           INPUT_JSON_DELTA = "input_json_delta"
+          THINKING_DELTA = "thinking_delta"
+          SIGNATURE_DELTA = "signature_delta"
         end
 
         # @yield [delta]
@@ -96,7 +99,12 @@ module OmniAI
         # @param data [Hash]
         def content_block_start(data)
           index = data["index"]
-          @data["content"][index] = data["content_block"]
+          content_block = data["content_block"]
+
+          # Initialize thinking content blocks with empty string for accumulation
+          content_block["thinking"] = "" if content_block["type"] == ContentBlockType::THINKING
+
+          @data["content"][index] = content_block
         end
 
         # Handler for Type::CONTENT_BLOCK_DELTA
@@ -109,8 +117,12 @@ module OmniAI
           case data["delta"]["type"]
           when ContentBlockDeltaType::TEXT_DELTA
             content_block_delta_for_text_delta(data, &)
+          when ContentBlockDeltaType::THINKING_DELTA
+            content_block_delta_for_thinking_delta(data, &)
           when ContentBlockDeltaType::INPUT_JSON_DELTA
             content_block_delta_for_input_json_delta(data, &)
+          when ContentBlockDeltaType::SIGNATURE_DELTA
+            content_block_delta_for_signature_delta(data)
           end
         end
 
@@ -125,11 +137,27 @@ module OmniAI
           text = data["delta"]["text"]
 
           content = @data["content"][index]
-          content["text"] += data["delta"]["text"]
+          content["text"] += text
 
           block&.call(OmniAI::Chat::Delta.new(text:))
         end
 
+        # Handler for Type::CONTENT_BLOCK_DELTA w/ ContentBlockDeltaType::THINKING_DELTA
+        #
+        # @yield [delta]
+        # @yieldparam delta [OmniAI::Chat::Delta]
+        #
+        # @param data [Hash]
+        def content_block_delta_for_thinking_delta(data, &block)
+          index = data["index"]
+          thinking = data["delta"]["thinking"]
+
+          content = @data["content"][index]
+          content["thinking"] += thinking
+
+          block&.call(OmniAI::Chat::Delta.new(thinking:))
+        end
+
         # Handler for Type::CONTENT_BLOCK_DELTA w/ ContentBlockDeltaType::INPUT_JSON_DELTA
         #
         # @yield [delta]
@@ -142,6 +170,15 @@ module OmniAI
           content["partial_json"] += data["delta"]["partial_json"]
         end
 
+        # Handler for Type::CONTENT_BLOCK_DELTA w/ ContentBlockDeltaType::SIGNATURE_DELTA
+        #
+        # @param data [Hash]
+        def content_block_delta_for_signature_delta(data)
+          content = @data["content"][data["index"]]
+          content["signature"] ||= ""
+          content["signature"] += data["delta"]["signature"]
+        end
+
         # Handler for Type::CONTENT_BLOCK_STOP
         #
         # @param data [Hash]
@@ -149,6 +186,11 @@ module OmniAI
           index = data["index"]
           content = @data["content"][index]
 
+          # Capture signature for thinking blocks (required for tool call round-trips)
+          signature = data.dig("content_block", "signature")
+          content["signature"] = signature if content["type"] == ContentBlockType::THINKING && signature
+
+          # Handle partial JSON for tool use blocks
           return unless content["partial_json"]
           return if content["partial_json"].empty?
 

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    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
+          OmniAI::Chat::Thinking.new(data["thinking"], metadata: { signature: data["signature"] })
+        end
+
+        # @param thinking [OmniAI::Chat::Thinking]
+        # @param context [Context]
+        #
+        # @return [Hash]
+        def self.serialize(thinking, context: nil) # rubocop:disable Lint/UnusedMethodArgument
+          {
+            type: "thinking",
+            thinking: thinking.thinking,
+            signature: thinking.metadata[:signature],
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/omniai/anthropic/chat.rb

@@ -76,18 +76,49 @@ module OmniAI
 
         context.deserializers[:content] = ContentSerializer.method(:deserialize)
         context.deserializers[:response] = ResponseSerializer.method(:deserialize)
+
+        context.serializers[:thinking] = ThinkingSerializer.method(:serialize)
+        context.deserializers[:thinking] = ThinkingSerializer.method(:deserialize)
       end
 
       # @return [Hash]
       def payload
-        OmniAI::Anthropic.config.chat_options.merge({
+        data = OmniAI::Anthropic.config.chat_options.merge({
           model: @model,
           messages:,
           system:,
           stream: stream? || nil,
-          temperature: @temperature,
+          temperature: thinking_config ? nil : @temperature, # Anthropic requires temperature=1 (default) when thinking
           tools: tools_payload,
+          thinking: thinking_config,
         }).compact
+
+        # When thinking is enabled, ensure max_tokens > budget_tokens
+        data[:max_tokens] = thinking_max_tokens if thinking_config
+
+        data
+      end
+
+      # Translates unified thinking option to Anthropic's native format.
+      # Example: `thinking: { budget_tokens: 10000 }` becomes `{ type: "enabled", budget_tokens: 10000 }`
+      # @return [Hash, nil]
+      def thinking_config
+        thinking = @options[:thinking]
+        return unless thinking
+
+        case thinking
+        when true then { type: "enabled", budget_tokens: 10_000 }
+        when Hash then { type: "enabled" }.merge(thinking)
+        end
+      end
+
+      # Returns max_tokens ensuring it's greater than budget_tokens when thinking is enabled.
+      # @return [Integer]
+      def thinking_max_tokens
+        budget = thinking_config[:budget_tokens]
+        base = @options[:max_tokens] || OmniAI::Anthropic.config.chat_options[:max_tokens] || 0
+        # Ensure max_tokens > budget_tokens (default to budget + 8000 for response)
+        [base, budget + 8_000].max
       end
 
       # @return [Array<Hash>]

data/lib/omniai/anthropic/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
     end
   end

data/lib/omniai/anthropic/version.rb

@@ -2,6 +2,6 @@
 
 module OmniAI
   module Anthropic
-    VERSION = "3.0.1"
+    VERSION = "3.1.1"
   end
 end

metadata

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