omniai-anthropic 1.6.3 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41fa9f2696b2457c4fdadf958b6e89c91555b4fad07b424455def24687fc77e5
-  data.tar.gz: 8e274f3203deddafc11be3b34d4947a5c95e0591180a605e09a54c4d3a4e8fe5
+  metadata.gz: 692299f3cf52f0f131202156f1fc5d0f973ec0488eff51f1e0186d3e88befa5d
+  data.tar.gz: 2d77787b55f8aa59acc9a33c92627451089fc63c988723963f0bf967dc30df40
 SHA512:
-  metadata.gz: 895ef4d62346311990d7ccb6d096321071414b492a8e7f2ed52bcfa49017da89b6db31ab66e5cee299dded336e28ef41e50e70478d3977422a0a1f5751ea3326
-  data.tar.gz: 852a864614cf0c6495820e830ef6159b8d5856afccdaad9dd664571ddcb18d24b9e7c24d80d15c1d085c850424c2213b54d60031aebd8d393c9210bcfd470bc7
+  metadata.gz: 97364e1f0f92ac5984dadaa4ff3e19b71463f2bc8acccc939b2f215e3d28daad8f4032d0b251f9253932134dc4c6808e71c80ab796f5c325c6108e4d76535019
+  data.tar.gz: 5697f26b5817a949aa4d5cf9e760de598a48c4ed298f9822bd659738ed3e0631b1cbaa98d8bad019e66501f6b331896e637a9f13608a07aa433be64749e54fff

data/README.md

@@ -40,7 +40,7 @@ A chat completion is generated by passing in prompts using any a variety of form
 
 ```ruby
 completion = client.chat('Tell me a joke!')
-completion.choice.message.content # 'Why did the chicken cross the road? To get to the other side.'
+completion.text # 'Why did the chicken cross the road? To get to the other side.'
 ```
 
 ```ruby
@@ -48,7 +48,7 @@ completion = client.chat do |prompt|
   prompt.system('You are a helpful assistant.')
   prompt.user('What is the capital of Canada?')
 end
-completion.choice.message.content # 'The capital of Canada is Ottawa.'
+completion.text # 'The capital of Canada is Ottawa.'
 ```
 
 #### Model
@@ -57,7 +57,7 @@ completion.choice.message.content # 'The capital of Canada is Ottawa.'
 
 ```ruby
 completion = client.chat('Provide code for fibonacci', model: OmniAI::Anthropic::Chat::Model::CLAUDE_SONNET)
-completion.choice.message.content # 'def fibonacci(n)...end'
+completion.text # 'def fibonacci(n)...end'
 ```
 
 [Anthropic API Reference `model`](https://docs.anthropic.com/en/api/messages)
@@ -68,7 +68,7 @@ completion.choice.message.content # 'def fibonacci(n)...end'
 
 ```ruby
 completion = client.chat('Pick a number between 1 and 5', temperature: 1.0)
-completion.choice.message.content # '3'
+completion.text # '3'
 ```
 
 [Anthropic API Reference `temperature`](https://docs.anthropic.com/en/api/messages)
@@ -79,7 +79,7 @@ completion.choice.message.content # '3'
 
 ```ruby
 stream = proc do |chunk|
-  print(chunk.choice.delta.content) # 'Better', 'three', 'hours', ...
+  print(chunk.text) # 'Better', 'three', 'hours', ...
 end
 client.chat('Be poetic.', stream:)
 ```
@@ -94,7 +94,7 @@ client.chat('Be poetic.', stream:)
 completion = client.chat(format: :json) do |prompt|
   prompt.system(OmniAI::Chat::JSON_PROMPT)
   prompt.user('What is the name of the drummer for the Beatles?')
-JSON.parse(completion.choice.message.content) # { "name": "Ringo" }
+JSON.parse(completion.text) # { "name": "Ringo" }
 ```
 
 [Anthropic API Reference `control-output-format`](https://docs.anthropic.com/en/docs/control-output-format)

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    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/anthropic/chat/content_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    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 'text' then OmniAI::Chat::Text.deserialize(data, context:)
+          when 'tool_use' then OmniAI::Chat::ToolCall.deserialize(data, context:)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    class Chat
+      # Overrides function serialize / deserialize.
+      module FunctionSerializer
+        # @param function [OmniAI::Chat::Function]
+        # @return [Hash]
+        def self.serialize(function, *)
+          {
+            name: function.name,
+            input: function.arguments,
+          }
+        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
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    class Chat
+      # Overrides media serialize / deserialize.
+      module MediaSerializer
+        # @param payload [OmniAI::Chat::Media]
+        # @return [Hash]
+        def self.serialize(media, *)
+          {
+            type: media.kind, # i.e. 'image' / 'video' / 'audio' / ...
+            source: {
+              type: 'base64',
+              media_type: media.type, # i.e. 'image/jpeg' / 'video/ogg' / 'audio/mpeg' / ...
+              data: media.data,
+            },
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    class Chat
+      # Overrides message serialize / deserialize.
+      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)
+          content = parts.map do |part|
+            case part
+            when String then { type: 'text', text: part }
+            else part.serialize(context:)
+            end
+          end
+
+          { role:, content: }
+        end
+
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        # @return [OmniAI::Chat::Message]
+        def self.deserialize(data, context:)
+          role = data['role']
+          parts = arrayify(data['content']).map do |content|
+            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) }
+
+          OmniAI::Chat::Message.new(content:, role:, 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/anthropic/chat/payload_serializer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    class Chat
+      # Overrides payload serialize / deserialize.
+      module PayloadSerializer
+        # @param payload [OmniAI::Chat::Payload]
+        # @param context [OmniAI::Context]
+        # @return [Hash]
+        def self.serialize(payload, context:)
+          usage = payload.usage.serialize(context:)
+          choice = payload.choice.serialize(context:)
+
+          choice.merge({ usage: })
+        end
+
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        # @return [OmniAI::Chat::Payload]
+        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:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    class Chat
+      # A stream given when streaming.
+      class Stream < OmniAI::Chat::Stream
+        module Type
+          PING = 'ping'
+          MESSAGE_START = 'message_start'
+          MESSAGE_STOP = 'message_stop'
+          MESSAGE_DELTA = 'message_delta'
+          CONTENT_BLOCK_START = 'content_block_start'
+          CONTENT_BLOCK_STOP = 'content_block_stop'
+          CONTENT_BLOCK_DELTA = 'content_block_delta'
+        end
+
+        # Process the stream into chunks by event.
+        class Builder
+          # @return [OmniAI::Chat::Payload, nil]
+          def payload(context:)
+            return unless @content
+
+            OmniAI::Chat::Payload.deserialize(@message.merge({
+              'content' => @content,
+            }), context:)
+          end
+
+          # Handler for Type::MESSAGE_START
+          #
+          # @param data [Hash]
+          def message_start(data)
+            @message = data['message']
+          end
+
+          # Handler for Type::MESSAGE_STOP
+          #
+          # @param _data [Hash]
+          def message_stop(_data)
+            @message = nil
+          end
+
+          # Handler for Type::CONTENT_BLOCK_START
+          #
+          # @param data [Hash]
+          def content_block_start(_data)
+            @content = nil
+          end
+
+          # Handler for Type::CONTENT_BLOCK_STOP
+          #
+          # @param _data [Hash]
+          def content_block_stop(_data)
+            @content = nil
+          end
+
+          # Handler for Type::CONTENT_BLOCK_DELTA
+          #
+          # @param data [Hash]
+          def content_block_delta(data)
+            @content = [{ 'type' => 'text', 'text' => data['delta']['text'] }]
+          end
+        end
+
+        protected
+
+        def builder
+          @builder ||= Builder.new
+        end
+
+        # @param type [String]
+        # @param data [Hash]
+        # @param builder [Builder]
+        def process!(type, data, id, &block)
+          log(type, data, id)
+
+          data = JSON.parse(data)
+
+          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)
+
+            payload = builder.payload(context: @context)
+            block.call(payload) if payload
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    class Chat
+      # Overrides text serialize / deserialize.
+      module TextSerializer
+        # @param text [OmniAI::Chat::Text]
+        # @return [Hash]
+        def self.serialize(text, *)
+          { type: '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/anthropic/chat/tool_call_result_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    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: 'tool_result',
+            tool_use_id: tool_call_result.tool_call_id,
+            content: tool_call_result.content,
+          }
+        end
+
+        # @param data [Hash]
+        # @return [OmniAI::Chat::ToolCallResult]
+        def self.deserialize(data, *)
+          tool_call_id = data['tool_use_id']
+          content = data['content']
+
+          OmniAI::Chat::ToolCallResult.new(content:, tool_call_id:)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    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:)
+          {
+            id: tool_call.id,
+            type: 'tool_use',
+          }.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/anthropic/chat/tool_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Anthropic
+    class Chat
+      # Overrides tool serialize / deserialize.
+      module ToolSerializer
+        # @param tool [OmniAI::Tool]
+        # @return [Hash]
+        def self.serialize(tool, *)
+          {
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.parameters.is_a?(Tool::Parameters) ? tool.parameters.serialize : tool.parameters,
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/omniai/anthropic/chat.rb

@@ -10,7 +10,7 @@ module OmniAI
     #     prompt.system('You are an expert in the field of AI.')
     #     prompt.user('What are the biggest risks of AI?')
     #   end
-    #   completion.choice.message.content # '...'
+    #   completion.text # '...'
     class Chat < OmniAI::Chat
       module Model
         CLAUDE_INSTANT_1_0 = 'claude-instant-1.2'
@@ -27,26 +27,30 @@ module OmniAI
 
       DEFAULT_MODEL = Model::CLAUDE_SONNET
 
-      # @param [Media]
-      # @return [Hash]
-      # @example
-      #   media = Media.new(...)
-      #   MEDIA_SERIALIZER.call(media)
-      MEDIA_SERIALIZER = lambda do |media, *|
-        {
-          type: media.kind, # i.e. 'image' / 'video' / 'audio' / ...
-          source: {
-            type: 'base64',
-            media_type: media.type, # i.e. 'image/jpeg' / 'video/ogg' / 'audio/mpeg' / ...
-            data: media.data,
-          },
-        }
-      end
-
       # @return [Context]
       CONTEXT = Context.build do |context|
-        context.serializers[:file] = MEDIA_SERIALIZER
-        context.serializers[:url] = MEDIA_SERIALIZER
+        context.serializers[:tool] = ToolSerializer.method(:serialize)
+
+        context.serializers[:file] = MediaSerializer.method(:serialize)
+        context.serializers[:url] = MediaSerializer.method(:serialize)
+
+        context.serializers[:choice] = ChoiceSerializer.method(:serialize)
+        context.deserializers[:choice] = ChoiceSerializer.method(:deserialize)
+
+        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[:function] = FunctionSerializer.method(:serialize)
+        context.deserializers[:function] = FunctionSerializer.method(:deserialize)
+
+        context.serializers[:message] = MessageSerializer.method(:serialize)
+        context.deserializers[:message] = MessageSerializer.method(:deserialize)
+
+        context.deserializers[:content] = ContentSerializer.method(:deserialize)
+        context.deserializers[:payload] = PayloadSerializer.method(:deserialize)
       end
 
       # @return [Hash]
@@ -63,14 +67,16 @@ module OmniAI
 
       # @return [Array<Hash>]
       def messages
-        messages = @prompt.messages.filter(&:user?)
-        messages.map { |message| message.serialize(context: CONTEXT) }
+        messages = @prompt.messages.reject(&:system?)
+        messages.map { |message| message.serialize(context:) }
       end
 
       # @return [String, nil]
       def system
         messages = @prompt.messages.filter(&:system?)
-        messages.map(&:content).join("\n\n") if messages.any?
+        return if messages.empty?
+
+        messages.filter(&:text?).map(&:text).join("\n\n")
       end
 
       # @return [String]
@@ -78,17 +84,27 @@ module OmniAI
         "/#{Client::VERSION}/messages"
       end
 
+      protected
+
+      # @return [Context]
+      def context
+        CONTEXT
+      end
+
+      # @return [Array<Message>]
+      def build_tool_call_messages(tool_call_list)
+        content = tool_call_list.map do |tool_call|
+          ToolCallResult.new(tool_call_id: tool_call.id, content: execute_tool_call(tool_call))
+        end
+
+        [Message.new(role: OmniAI::Chat::Role::USER, content:)]
+      end
+
       private
 
       # @return [Array<Hash>, nil]
       def tools_payload
-        @tools&.map do |tool|
-          {
-            name: tool.name,
-            description: tool.description,
-            input_schema: tool.parameters&.prepare,
-          }.compact
-        end
+        @tools.map { |tool| tool.serialize(context:) } if @tools&.any?
       end
     end
   end

data/lib/omniai/anthropic/version.rb

@@ -2,6 +2,6 @@
 
 module OmniAI
   module Anthropic
-    VERSION = '1.6.3'
+    VERSION = '1.8.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omniai-anthropic
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.8.1
 platform: ruby
 authors:
 - Kevin Sylvestre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-19 00:00:00.000000000 Z
+date: 2024-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -63,8 +63,17 @@ files:
 - README.md
 - lib/omniai/anthropic.rb
 - lib/omniai/anthropic/chat.rb
-- lib/omniai/anthropic/chat/response/completion.rb
-- lib/omniai/anthropic/chat/response/stream.rb
+- lib/omniai/anthropic/chat/choice_serializer.rb
+- lib/omniai/anthropic/chat/content_serializer.rb
+- 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/stream.rb
+- lib/omniai/anthropic/chat/text_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
 - lib/omniai/anthropic/client.rb
 - lib/omniai/anthropic/config.rb
 - lib/omniai/anthropic/version.rb

data/lib/omniai/anthropic/chat/response/completion.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module OmniAI
-  module Anthropic
-    class Chat
-      module Response
-        # A completion returned by the API.
-        class Completion < OmniAI::Chat::Response::Completion
-          # @return [Array<OmniAI::Chat::Response::MessageChoice>]
-          def choices
-            @choices ||= begin
-              role = @data['role']
-
-              @data['content'].map do |data, index|
-                OmniAI::Chat::Response::MessageChoice.new(data: {
-                  'index' => index,
-                  'message' => {
-                    'role' => role,
-                    'content' => data['text'],
-                  },
-                })
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module OmniAI
-  module Anthropic
-    class Chat
-      module Response
-        # A stream given when streaming.
-        class Stream < OmniAI::Chat::Response::Stream
-          module Type
-            PING = 'ping'
-            MESSAGE_START = 'message_start'
-            MESSAGE_STOP = 'message_stop'
-            MESSAGE_DELTA = 'message_delta'
-            CONTENT_BLOCK_START = 'content_block_start'
-            CONTENT_BLOCK_STOP = 'content_block_stop'
-            CONTENT_BLOCK_DELTA = 'content_block_delta'
-          end
-
-          # Process the stream into chunks by event.
-          class Builder
-            attr_reader :id, :model, :role, :content, :index
-
-            # @return [OmniAI::Chat::Chunk]
-            def chunk
-              OmniAI::Chat::Response::Chunk.new(data: {
-                'id' => @id,
-                'model' => @model,
-                'choices' => [{
-                  'index' => @index,
-                  'delta' => {
-                    'role' => @role,
-                    'content' => @content,
-                  },
-                }],
-              })
-            end
-
-            # Handler for Type::MESSAGE_START
-            #
-            # @param data [Hash]
-            def message_start(data)
-              @id = data['id']
-              @model = data['model']
-              @role = data['role']
-            end
-
-            # Handler for Type::MESSAGE_STOP
-            #
-            # @param _data [Hash]
-            def message_stop(_data)
-              @id = nil
-              @model = nil
-              @role = nil
-            end
-
-            # Handler for Type::CONTENT_BLOCK_START
-            #
-            # @param data [Hash]
-            def content_block_start(data)
-              @index = data['index']
-            end
-
-            # Handler for Type::CONTENT_BLOCK_STOP
-            #
-            # @param _data [Hash]
-            def content_block_stop(_data)
-              @index = nil
-            end
-
-            # Handler for Type::CONTENT_BLOCK_DELTA
-            #
-            # @param data [Hash]
-            def content_block_delta(data)
-              return unless data['delta']['type'].eql?('text_delta')
-
-              @content = data['delta']['text']
-            end
-          end
-
-          # @yield [OmniAI::Chat::Chunk]
-          def stream!(&block)
-            builder = Builder.new
-
-            @response.body.each do |chunk|
-              @parser.feed(chunk) do |type, data|
-                process(type:, data: JSON.parse(data), builder:, &block)
-              end
-            end
-          end
-
-          private
-
-          # @param type [String]
-          # @param data [Hash]
-          # @param builder [Builder]
-          def process(type:, data:, builder:, &)
-            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)
-              yield(builder.chunk)
-            end
-          end
-        end
-      end
-    end
-  end
-end