lex-llm-bedrock 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ef7a8a909bb86688882fc9ffca3c7fd96955d75cb01e5048efa954909599c49
-  data.tar.gz: 90d58f5f3e6f976b2332341e6f5624064a5b70f7ce5381d4df94b082d7398ab7
+  metadata.gz: 1d0b15f1168f45e6f11211963cc8c0939085562bd92e720bcd74426367824318
+  data.tar.gz: e68d8865e321e62f0b7c54cf16a573286174626531229b325e53b0aecbc8c3ea
 SHA512:
-  metadata.gz: ab5e3feccaee75a608ba7032721bd899e74e9059bfee3704ebc45b1f1733a5341eb2e1f1f99be48bdc2b0eee4555aaf8985e1c84a2c673474dbc4ae018abf6b7
-  data.tar.gz: 61b3a978d40a10d91f725ffd3ebc7b937596fa60740fb9e3d168cbba6f19fc2a50f27af56a637612c4980b1e4408dcae61e2148fff6b819026ed35811fbdcf6c
+  metadata.gz: ac5ed2ff6e4d586891edc3d05a8935cd32b25b561862a882c04a17d2c42324f8cfde527338c8d464cc8373d06dfa4b758fc3a7ab4c1ac70072d22d9998799207
+  data.tar.gz: 1e6f4bd752aa5fe9eeb033426405718826135763e2f6974674a7238ffbf74134024ad8f164962d02dc908aa8276417451087c7092e623beda5e0df58977efbf4

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.3.9 - 2026-05-18
+
+- Fix streaming tool call parsing: `stream_converse` now handles content_block_start/delta/stop events for tool_use blocks, capturing tool ids, names, and accumulated input JSON. Previously only text deltas were captured and tool calls were silently dropped.
+
+
 ## 0.3.8 - 2026-05-13
 
 - Auto-prefix `us.` on `inference_profile_id` for Anthropic, Meta, Mistral, Cohere, and AI21 models at API call time.

data/lib/legion/extensions/llm/bedrock/provider.rb

@@ -474,30 +474,99 @@ module Legion
           end
 
           def stream_converse(request, fallback_model)
-            accumulated = +''
-            final_usage = nil
+            state = { accumulated: +'', final_usage: nil, stop_reason: nil, tool_use_blocks: [], current_tool_use: nil }
 
             runtime_client.converse_stream(**request) do |stream|
-              stream.on_content_block_delta_event do |event|
-                text = value(value(event, :delta), :text)
-                next if text.nil?
+              wire_stream_handlers(stream, state, fallback_model) { |chunk| yield chunk if block_given? }
+            end
+
+            Legion::Extensions::Llm::Message.new(
+              role: :assistant,
+              content: state[:accumulated],
+              model_id: fallback_model,
+              tool_calls: build_stream_tool_calls(state[:tool_use_blocks]),
+              input_tokens: value(state[:final_usage], :input_tokens),
+              output_tokens: value(state[:final_usage], :output_tokens),
+              stop_reason: state[:stop_reason]
+            )
+          end
+
+          def wire_stream_handlers(stream, state, fallback_model, &)
+            wire_block_start(stream, state)
+            wire_block_delta(stream, state, fallback_model, &)
+            wire_block_stop(stream, state)
+            wire_message_stop(stream, state)
+            stream.on_metadata_event { |event| state[:final_usage] = value(event, :usage) }
+          end
 
-                accumulated << text
+          def wire_block_start(stream, state)
+            return unless stream.respond_to?(:on_content_block_start_event)
+
+            stream.on_content_block_start_event do |event|
+              start = value(event, :start)
+              tool_start = value(start, :tool_use) if start
+              next unless tool_start
+
+              state[:current_tool_use] = {
+                tool_use_id: value(tool_start, :tool_use_id),
+                name: value(tool_start, :name),
+                input_json: +''
+              }
+            end
+          end
+
+          def wire_block_delta(stream, state, fallback_model)
+            stream.on_content_block_delta_event do |event|
+              delta = value(event, :delta)
+              text = value(delta, :text)
+              if text
+                state[:accumulated] << text
                 if block_given?
                   yield Legion::Extensions::Llm::Chunk.new(role: :assistant, content: text,
                                                            model_id: fallback_model)
                 end
               end
-              stream.on_metadata_event { |event| final_usage = value(event, :usage) }
+
+              tool_input = value(delta, :tool_use)
+              next unless tool_input && state[:current_tool_use]
+
+              input_chunk = value(tool_input, :input)
+              state[:current_tool_use][:input_json] << input_chunk.to_s if input_chunk
             end
+          end
 
-            Legion::Extensions::Llm::Message.new(
-              role: :assistant,
-              content: accumulated,
-              model_id: fallback_model,
-              input_tokens: value(final_usage, :input_tokens),
-              output_tokens: value(final_usage, :output_tokens)
-            )
+          def wire_block_stop(stream, state)
+            return unless stream.respond_to?(:on_content_block_stop_event)
+
+            stream.on_content_block_stop_event do |_event|
+              next unless state[:current_tool_use]
+
+              state[:tool_use_blocks] << state[:current_tool_use]
+              state[:current_tool_use] = nil
+            end
+          end
+
+          def wire_message_stop(stream, state)
+            return unless stream.respond_to?(:on_message_stop_event)
+
+            stream.on_message_stop_event do |event|
+              state[:stop_reason] = value(event, :stop_reason)
+            end
+          end
+
+          def build_stream_tool_calls(tool_use_blocks)
+            return nil if tool_use_blocks.empty?
+
+            tool_use_blocks.to_h do |block|
+              input = begin
+                Legion::JSON.load(block[:input_json])
+              rescue StandardError
+                {}
+              end
+              name = block[:name]
+              id = block[:tool_use_id] || name
+              [id, Legion::Extensions::Llm::ToolCall.new(id: id, name: name, arguments: input)]
+            end
           end
 
           def parse_embedding_response(response, model:)

data/lib/legion/extensions/llm/bedrock/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
-        VERSION = '0.3.8'
+        VERSION = '0.3.9'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-bedrock
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - LegionIO