lex-llm-bedrock 0.3.8 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ef7a8a909bb86688882fc9ffca3c7fd96955d75cb01e5048efa954909599c49
-  data.tar.gz: 90d58f5f3e6f976b2332341e6f5624064a5b70f7ce5381d4df94b082d7398ab7
+  metadata.gz: a0d6ffe6c93fec2590c74ed5a01a944c81694fb98316bf35bde08db6efecfed9
+  data.tar.gz: 3e5174849ecf00a36f79e8926237f430ce1b1e8a8572c4fede2463e5cc0a3bda
 SHA512:
-  metadata.gz: ab5e3feccaee75a608ba7032721bd899e74e9059bfee3704ebc45b1f1733a5341eb2e1f1f99be48bdc2b0eee4555aaf8985e1c84a2c673474dbc4ae018abf6b7
-  data.tar.gz: 61b3a978d40a10d91f725ffd3ebc7b937596fa60740fb9e3d168cbba6f19fc2a50f27af56a637612c4980b1e4408dcae61e2148fff6b819026ed35811fbdcf6c
+  metadata.gz: 273bc8934934e7eb40e9365a57de5fb33c12114c84b435b353ffb3e0e83329ced120f94016ddc59bd8cfc484c3a35094814f41beb8b0361ece513417505954d5
+  data.tar.gz: 2d36dcff70b35577a0d5bbf6846ed6181851e6ac32d8cd65f67367429f32ec88869a084ccc4e3fdde200ab50ae3ca6c21509c84fa7a4af5ae360eaf75b85a2c5

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.3.10 - 2026-05-21
+
+- Add `default_transport`/`default_tier` class declarations, remove `configured_transport`/`configured_tier`
+- Add `model_allowed?` filtering in `discover_offerings` (handles ModelOffering objects)
+- Move `DEFAULT_REGION` to settings[:region]
+- Default tier corrected from :frontier to :cloud
+- Identity headers included via base provider
+
+
+## 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

@@ -14,8 +14,6 @@ module Legion
         class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
           include Legion::Logging::Helper
 
-          DEFAULT_REGION = 'us-east-1'
-
           STATIC_MODELS = [
             { model: 'anthropic.claude-3-haiku-20240307-v1:0', alias: 'claude-3-haiku' },
             { model: 'amazon.titan-text-express-v1', alias: 'titan-text-express' },
@@ -50,6 +48,8 @@ module Legion
 
           class << self
             def slug = 'bedrock'
+            def default_transport = :aws_sdk
+            def default_tier = :cloud
 
             def configuration_options
               %i[
@@ -113,7 +113,7 @@ module Legion
           def count_tokens_url = 'CountTokens'
 
           def region
-            config.bedrock_region || DEFAULT_REGION
+            config.bedrock_region || settings[:region] || 'us-east-1'
           end
 
           def discover_offerings(live: false, **filters)
@@ -126,8 +126,12 @@ module Legion
 
             log.info { "bedrock.provider.discover_offerings: listing foundation models (region=#{region})" }
             response = bedrock_client.list_foundation_models(**filters)
-            @cached_offerings = Array(value(response, :model_summaries)).map do |summary|
-              offering_from_summary(summary)
+            @cached_offerings = Array(value(response, :model_summaries)).filter_map do |summary|
+              offering = offering_from_summary(summary)
+              model_id = offering.respond_to?(:model) ? offering.model : (offering[:model] || offering[:id])
+              next unless model_allowed?(model_id.to_s)
+
+              offering
             end
             log.info { "bedrock.provider.discover_offerings: found #{@cached_offerings.size} models" }
             @cached_offerings
@@ -323,8 +327,8 @@ module Legion
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :bedrock,
               instance_id: instance_id,
-              transport: configured_transport(:aws_sdk),
-              tier: configured_tier(:frontier),
+              transport: offering_transport,
+              tier: offering_tier,
               model: model,
               usage_type: usage_type,
               capabilities: capabilities || default_capabilities(model),
@@ -346,14 +350,6 @@ module Legion
             ctx ? { context_window: ctx } : nil
           end
 
-          def configured_transport(default)
-            config.respond_to?(:transport) ? config.transport : default
-          end
-
-          def configured_tier(default)
-            config.respond_to?(:tier) ? config.tier : default
-          end
-
           def converse_request(messages, model:, temperature:, max_tokens:, tools:, tool_prefs:)
             {
               model_id: self.class.inference_profile_id(model_id(model)),
@@ -474,30 +470,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
+
+          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
 
-                accumulated << text
+          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.10'
       end
     end
   end

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

@@ -23,7 +23,8 @@ module Legion
             family: PROVIDER_FAMILY,
             instance: {
               default_model: 'us.anthropic.claude-sonnet-4-6',
-              tier: :frontier,
+              region: 'us-east-1',
+              tier: :cloud,
               transport: :aws_sdk,
               credentials: {
                 bearer_token: nil,

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.10
 platform: ruby
 authors:
 - LegionIO