omniai-anthropic 1.9.8 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee6ca2cb64add94603589ca1cfb5b8e096042a0d60bdf6a00f4ee7288f52047a
-  data.tar.gz: eb9eddc32df781539751b92a34ab502a3c0622fb2760583bb38191a2f704b659
+  metadata.gz: ed3bbf0fe24852928799eeeffc76163c4d45a68c2ae5070f46b57590e1da8b60
+  data.tar.gz: d330deaf3dfe93d3fd1d9c64b86656668708b3936f9bdbd6445abc3f7ed2bc98
 SHA512:
-  metadata.gz: 892593c2136b1dd2f84b4523350030543811fd32b8991cdccca7f5a00fa8289ab1f38f708093d8ea81cd14c58014331323a9420c314a0a29480755fa69e49596
-  data.tar.gz: 8fc61070743f464d2e136b68ed608457eff12624baffa4b59aadf32674cc74b5da6967c6858a11f436480575a2a5918e392cea216616128e6f4a1bb45ebd1419
+  metadata.gz: 92315dd5847588f9b344dc6111d5a0e5b4176cc72dba14c275de14d7cd0d7a2ba03a60608ba0d2cc8ba341cff566bcae838f762d807c0fdb2218cac1b3068650
+  data.tar.gz: 1db95ee64d3a6ad40f289a05dacc0d2154a0b0de016502864c4103834cc9a69568a591641bb4f94957cdf3ef93b147f5503776e228717ad55a6ac2b1869bb56f

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

@@ -6,6 +6,7 @@ module OmniAI
       # Overrides function serialize / deserialize.
       module FunctionSerializer
         # @param function [OmniAI::Chat::Function]
+        #
         # @return [Hash]
         def self.serialize(function, *)
           {
@@ -15,10 +16,12 @@ module OmniAI
         end
 
         # @param data [Hash]
+        #
         # @return [OmniAI::Chat::Function]
         def self.deserialize(data, *)
           name = data["name"]
           arguments = data["input"]
+
           OmniAI::Chat::Function.new(name:, arguments:)
         end
       end

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

@@ -5,7 +5,7 @@ module OmniAI
     class Chat
       # Overrides media serialize / deserialize.
       module MediaSerializer
-        # @param payload [OmniAI::Chat::Media]
+        # @param media [OmniAI::Chat::Media]
         # @return [Hash]
         def self.serialize(media, *)
           {

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

@@ -7,10 +7,12 @@ module OmniAI
       module MessageSerializer
         # @param message [OmniAI::Chat::Message]
         # @param context [OmniAI::Context]
+        #
         # @return [Hash]
         def self.serialize(message, context:)
           role = message.role
-          parts = arrayify(message.content) + arrayify(message.tool_call_list)
+          parts = arrayify(message.content) + arrayify(message.tool_call_list&.entries)
+
           content = parts.map do |part|
             case part
             when String then { type: "text", text: part }
@@ -23,6 +25,7 @@ module OmniAI
 
         # @param data [Hash]
         # @param context [OmniAI::Context]
+        #
         # @return [OmniAI::Chat::Message]
         def self.deserialize(data, context:)
           role = data["role"]
@@ -30,8 +33,11 @@ module OmniAI
             ContentSerializer.deserialize(content, context:)
           end
 
-          tool_call_list = parts.select { |part| part.is_a?(OmniAI::Chat::ToolCall) }
-          content = parts.reject { |part| part.is_a?(OmniAI::Chat::ToolCall) }
+          tool_call_parts = parts.select { |part| part.is_a?(OmniAI::Chat::ToolCall) }
+          non_tool_call_parts = parts.reject { |part| part.is_a?(OmniAI::Chat::ToolCall) }
+
+          tool_call_list = OmniAI::Chat::ToolCallList.new(entries: tool_call_parts) if tool_call_parts.any?
+          content = non_tool_call_parts if non_tool_call_parts.any?
 
           OmniAI::Chat::Message.new(content:, role:, tool_call_list:)
         end

data/lib/omniai/anthropic/chat/{payload_serializer.rb → response_serializer.rb}

@@ -3,26 +3,28 @@
 module OmniAI
   module Anthropic
     class Chat
-      # Overrides payload serialize / deserialize.
-      module PayloadSerializer
-        # @param payload [OmniAI::Chat::Payload]
+      # Overrides response serialize / deserialize.
+      module ResponseSerializer
+        # @param response [OmniAI::Chat::Response]
         # @param context [OmniAI::Context]
+        #
         # @return [Hash]
-        def self.serialize(payload, context:)
-          usage = payload.usage.serialize(context:)
-          choice = payload.choice.serialize(context:)
+        def self.serialize(response, context:)
+          usage = response.usage.serialize(context:)
+          choice = response.choice.serialize(context:)
 
           choice.merge({ usage: })
         end
 
         # @param data [Hash]
         # @param context [OmniAI::Context]
-        # @return [OmniAI::Chat::Payload]
+        #
+        # @return [OmniAI::Chat::Response]
         def self.deserialize(data, context:)
           usage = OmniAI::Chat::Usage.deserialize(data["usage"], context:) if data["usage"]
           choice = OmniAI::Chat::Choice.deserialize(data, context:)
 
-          OmniAI::Chat::Payload.new(choices: [choice], usage:)
+          OmniAI::Chat::Response.new(data:, choices: [choice], usage:)
         end
       end
     end

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

@@ -3,90 +3,156 @@
 module OmniAI
   module Anthropic
     class Chat
-      # A stream given when streaming.
+      # Combine chunks into a hash. For each chunk yield the text (delta) if a block is given and the chunk is text.
       class Stream < OmniAI::Chat::Stream
         module Type
-          PING = "ping"
           MESSAGE_START = "message_start"
-          MESSAGE_STOP = "message_stop"
           MESSAGE_DELTA = "message_delta"
+          MESSAGE_STOP = "message_stop"
           CONTENT_BLOCK_START = "content_block_start"
-          CONTENT_BLOCK_STOP = "content_block_stop"
           CONTENT_BLOCK_DELTA = "content_block_delta"
+          CONTENT_BLOCK_STOP = "content_block_stop"
         end
 
-        # Process the stream into chunks by event.
-        class Builder
-          # @return [OmniAI::Chat::Payload, nil]
-          def payload(context:)
-            return unless @content
+        module ContentBlockType
+          TEXT = "text"
+          TOOL_USE = "tool_use"
+        end
 
-            OmniAI::Chat::Payload.deserialize(@message.merge({
-              "content" => @content,
-            }), context:)
-          end
+        module ContentBlockDeltaType
+          TEXT_DELTA = "text_delta"
+          INPUT_JSON_DELTA = "input_json_delta"
+        end
 
-          # Handler for Type::MESSAGE_START
-          #
-          # @param data [Hash]
-          def message_start(data)
-            @message = data["message"]
-          end
+        # @yield [delta]
+        # @yieldparam delta [OmniAI::Chat::Delta]
+        #
+        # @return [Hash]
+        def stream!(&block)
+          @data = { "content" => [] }
 
-          # Handler for Type::MESSAGE_STOP
-          #
-          # @param _data [Hash]
-          def message_stop(_data)
-            @message = nil
+          @chunks.each do |chunk|
+            parser.feed(chunk) do |type, data, id|
+              process!(type, data, id, &block)
+            end
           end
 
-          # Handler for Type::CONTENT_BLOCK_START
-          #
-          # @param data [Hash]
-          def content_block_start(_data)
-            @content = nil
-          end
+          @data
+        end
 
-          # Handler for Type::CONTENT_BLOCK_STOP
-          #
-          # @param _data [Hash]
-          def content_block_stop(_data)
-            @content = nil
+      protected
+
+        # @yield delta
+        # @yieldparam delta [OmniAI::Chat::Delta]
+        #
+        # @param type [String]
+        # @param data [Hash]
+        # @param id [String]
+        def process!(type, data, id, &)
+          log(type, data, id)
+
+          data = JSON.parse(data)
+
+          case data["type"]
+          when Type::MESSAGE_START then message_start(data)
+          when Type::MESSAGE_DELTA then message_delta(data)
+          when Type::MESSAGE_STOP then message_stop(data)
+          when Type::CONTENT_BLOCK_START then content_block_start(data)
+          when Type::CONTENT_BLOCK_DELTA then content_block_delta(data, &)
+          when Type::CONTENT_BLOCK_STOP then content_block_stop(data)
           end
+        end
 
-          # Handler for Type::CONTENT_BLOCK_DELTA
-          #
-          # @param data [Hash]
-          def content_block_delta(data)
-            @content = [{ "type" => "text", "text" => data["delta"]["text"] }]
+        # Handler for Type::MESSAGE_START
+        #
+        # @param data [Hash]
+        def message_start(data)
+          @data = data["message"]
+        end
+
+        # Handler for Type::MESSAGE_DELTA
+        #
+        # @param data [Hash]
+        def message_delta(data)
+          @data.merge!(data["delta"])
+
+          input_tokens = data.dig("usage", "input_tokens")
+          output_tokens = data.dig("usage", "output_tokens")
+
+          @data["usage"] ||= {}
+          @data["usage"]["input_tokens"] = input_tokens if input_tokens
+          @data["usage"]["output_tokens"] = output_tokens if output_tokens
+        end
+
+        # Handler for Type::MESSAGE_STOP
+        #
+        # @param _data [Hash]
+        def message_stop(_data)
+          # NOOP
+        end
+
+        # Handler for Type::CONTENT_BLOCK_START
+        #
+        # @param data [Hash]
+        def content_block_start(data)
+          index = data["index"]
+          @data["content"][index] = data["content_block"]
+        end
+
+        # Handler for Type::CONTENT_BLOCK_DELTA
+        #
+        # @yield [delta]
+        # @yieldparam delta [OmniAI::Chat::Delta]
+        #
+        # @param data [Hash]
+        def content_block_delta(data, &)
+          case data["delta"]["type"]
+          when ContentBlockDeltaType::TEXT_DELTA
+            content_block_delta_for_text_delta(data, &)
+          when ContentBlockDeltaType::INPUT_JSON_DELTA
+            content_block_delta_for_input_json_delta(data, &)
           end
         end
 
-      protected
+        # Handler for Type::CONTENT_BLOCK_DELTA w/ ContentBlockDeltaType::TEXT_DELTA
+        #
+        # @yield [delta]
+        # @yieldparam delta [OmniAI::Chat::Delta]
+        #
+        # @param data [Hash]
+        def content_block_delta_for_text_delta(data, &block)
+          index = data["index"]
+          text = data["delta"]["text"]
+
+          content = @data["content"][index]
+          content["text"] += data["delta"]["text"]
 
-        def builder
-          @builder ||= Builder.new
+          block&.call(OmniAI::Chat::Delta.new(text: text))
         end
 
-        # @param type [String]
+        # Handler for Type::CONTENT_BLOCK_DELTA w/ ContentBlockDeltaType::INPUT_JSON_DELTA
+        #
+        # @yield [delta]
+        # @yieldparam delta [OmniAI::Chat::Delta]
+        #
         # @param data [Hash]
-        # @param builder [Builder]
-        def process!(type, data, id, &block)
-          log(type, data, id)
+        def content_block_delta_for_input_json_delta(data)
+          content = @data["content"][data["index"]]
+          content["partial_json"] ||= ""
+          content["partial_json"] += data["delta"]["partial_json"]
+        end
 
-          data = JSON.parse(data)
+        # Handler for Type::CONTENT_BLOCK_STOP
+        #
+        # @param _data [Hash]
+        def content_block_stop(data)
+          index = data["index"]
+          content = @data["content"][index]
 
-          case type
-          when Type::MESSAGE_START then builder.message_start(data)
-          when Type::CONTENT_BLOCK_START then builder.content_block_start(data)
-          when Type::CONTENT_BLOCK_STOP then builder.content_block_stop(data)
-          when Type::MESSAGE_STOP then builder.message_stop(data)
-          when Type::CONTENT_BLOCK_DELTA
-            builder.content_block_delta(data)
+          return unless content["partial_json"]
 
-            payload = builder.payload(context: @context)
-            block.call(payload) if payload
-          end
+          content["input"] = JSON.parse(content["partial_json"])
+          content.delete("partial_json")
         end
       end
     end

data/lib/omniai/anthropic/chat.rb

@@ -61,7 +61,7 @@ module OmniAI
         context.deserializers[:message] = MessageSerializer.method(:deserialize)
 
         context.deserializers[:content] = ContentSerializer.method(:deserialize)
-        context.deserializers[:payload] = PayloadSerializer.method(:deserialize)
+        context.deserializers[:response] = ResponseSerializer.method(:deserialize)
       end
 
       # @return [Hash]

data/lib/omniai/anthropic/version.rb

@@ -2,6 +2,6 @@
 
 module OmniAI
   module Anthropic
-    VERSION = "1.9.8"
+    VERSION = "2.0.0"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: omniai-anthropic
 version: !ruby/object:Gem::Version
-  version: 1.9.8
+  version: 2.0.0
 platform: ruby
 authors:
 - Kevin Sylvestre
 bindir: exe
 cert_chain: []
-date: 2025-02-27 00:00:00.000000000 Z
+date: 2025-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +67,7 @@ files:
 - lib/omniai/anthropic/chat/function_serializer.rb
 - lib/omniai/anthropic/chat/media_serializer.rb
 - lib/omniai/anthropic/chat/message_serializer.rb
-- lib/omniai/anthropic/chat/payload_serializer.rb
+- lib/omniai/anthropic/chat/response_serializer.rb
 - lib/omniai/anthropic/chat/stream.rb
 - lib/omniai/anthropic/chat/text_serializer.rb
 - lib/omniai/anthropic/chat/tool_call_result_serializer.rb