lex-llm-bedrock 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59c2c3fda768fc58435dbe327fd8314e4b9dbfdbdf978e9220e3ad4999e42bc1
+  data.tar.gz: 8b448d4dbb18e1c8d2d3dde0c817cc49591142d5bc88c6057cf8f8f28d3cab8d
+SHA512:
+  metadata.gz: 47d5d1f35bd64d93db2e068b988a4ff9bb3d8622726f23cfe897b282f8cd1c4f454a44b82c170c04831c108226f373869121ac9a61f574bf023a13a8d9c92c8b
+  data.tar.gz: 2c9679fabbce22abde6a5f7e58da92c34e113afe5b6f166e3956ee6c91034f7178737e95897a93ba348750c85358822b3dc464841dfcbbf37d74ceb66469ef03

data/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @LegionIO/maintainers

data/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/coverage/
+/pkg/
+/tmp/
+Gemfile.lock
+*.gem
+
+.rspec_status*
+.env
+.claude
+AGENTS.md
+CLAUDE.md

data/.rubocop.yml

@@ -0,0 +1,32 @@
+plugins:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+  SuggestExtensions: false
+
+Metrics/BlockLength:
+  Exclude:
+    - "*.gemspec"
+    - spec/**/*
+Metrics/MethodLength:
+  Enabled: false
+Metrics/ParameterLists:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/LeakyConstantDeclaration:
+  Enabled: false
+RSpec/InstanceVariable:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 0.1.0 - 2026-04-28
+
+- Initial Legion::Extensions::Llm Bedrock provider extension scaffold.
+- Add offline provider defaults, model offering mapping, AWS SDK client construction, chat, streaming, embeddings, token counting, health, and live discovery entrypoints.
+- Add README, gemspec, CI, and stubbed unit specs for Bedrock routing behavior.

data/Gemfile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+group :test do
+  llm_base_path = ENV.fetch('LEX_LLM_PATH', File.expand_path('../lex-llm', __dir__))
+  gem 'lex-llm', path: llm_base_path if File.directory?(llm_base_path)
+end
+
+gemspec
+
+group :development do
+  gem 'bundler', '>= 2.0'
+  gem 'rake', '>= 13.0'
+  gem 'rspec', '~> 3.12'
+  gem 'rubocop', '>= 1.0'
+  gem 'rubocop-performance'
+  gem 'rubocop-rake', '>= 0.6'
+  gem 'rubocop-rspec'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LegionIO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# lex-llm-bedrock
+
+Amazon Bedrock provider extension for `Legion::Extensions::Llm`.
+
+This gem adds a hosted Bedrock provider surface for Legion LLM routing without depending on the old `legion-llm` gem. It uses the official AWS SDK for Ruby and keeps discovery offline by default, so loading the extension or running tests does not require live AWS credentials.
+
+## Install
+
+```ruby
+gem 'lex-llm-bedrock'
+```
+
+## Configuration
+
+The provider registers the `:bedrock` provider family with `Legion::Extensions::Llm::Provider`.
+
+```ruby
+require 'legion/extensions/llm/bedrock'
+
+Legion::Extensions::Llm.configure do |config|
+  config.bedrock_region = ENV.fetch('AWS_REGION', 'us-east-1')
+  config.bedrock_access_key_id = ENV['AWS_ACCESS_KEY_ID']
+  config.bedrock_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+  config.bedrock_session_token = ENV['AWS_SESSION_TOKEN']
+end
+```
+
+If explicit keys are not configured, the AWS SDK default credential provider chain is used. Default settings expose `env://` credential references and mark live discovery disabled:
+
+```ruby
+Legion::Extensions::Llm::Bedrock.default_settings
+```
+
+## Provider Surface
+
+```ruby
+provider = Legion::Extensions::Llm::Bedrock::Provider.new(Legion::Extensions::Llm.config)
+
+provider.discover_offerings(live: false)
+provider.offering_for(model: 'anthropic.claude-3-haiku-20240307-v1:0')
+provider.health(live: false)
+provider.chat(messages, model: model)
+provider.stream(messages, model: model) { |chunk| chunk.content }
+provider.embed('hello', model: 'amazon.titan-embed-text-v2:0')
+provider.count_tokens(messages, model: model)
+```
+
+`discover_offerings(live: false)` returns a small static catalog that is useful for routing defaults and unit tests. `discover_offerings(live: true)` calls Bedrock `ListFoundationModels` and maps the returned model summaries into `Legion::Extensions::Llm::Routing::ModelOffering` records.
+
+## Model Offerings
+
+Every offering uses:
+
+- `provider_family: :bedrock`
+- `transport: :aws_sdk`
+- the Bedrock model ID as `model`
+- `metadata[:model_family]` inferred from the provider prefix or accepted from the caller
+
+Known aliases are intentionally small and conservative. For example, `claude-3-haiku` resolves to `anthropic.claude-3-haiku-20240307-v1:0`, while the preserved Bedrock model ID remains the routing model.
+
+## API Contract
+
+The implementation is intentionally limited to Bedrock operations documented by AWS:
+
+- `ListFoundationModels` for live model discovery
+- `Converse` for chat-style inference
+- `ConverseStream` for streaming chat responses
+- `CountTokens` for token estimates
+- `InvokeModel` only for the Titan text embedding request shape implemented here
+
+Provider-specific request bodies are not guessed. Non-Titan embedding models raise until their documented body shape is added explicitly.
+
+AWS references:
+
+- [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
+- [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)
+- [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)
+- [ListFoundationModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListFoundationModels.html)
+- [Foundation model information](https://docs.aws.amazon.com/bedrock/latest/userguide/foundation-models-reference.html)

data/lex-llm-bedrock.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/llm/bedrock/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-llm-bedrock'
+  spec.version       = Legion::Extensions::Llm::Bedrock::VERSION
+  spec.authors       = ['LegionIO']
+  spec.email         = ['matthewdiverson@gmail.com']
+  spec.summary       = 'LegionIO LLM Amazon Bedrock provider extension'
+  spec.description   = 'Amazon Bedrock provider integration for the LegionIO LLM routing framework.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-llm-bedrock'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['documentation_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |file| file.match(%r{^(spec|test|features|tmp|coverage)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'aws-sdk-bedrock'
+  spec.add_dependency 'aws-sdk-bedrockruntime'
+  spec.add_dependency 'legion-json', '>= 1.2.1'
+  spec.add_dependency 'legion-logging', '>= 1.3.2'
+  spec.add_dependency 'legion-settings', '>= 1.3.14'
+  spec.add_dependency 'lex-llm', '>= 0.1.3'
+end

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

@@ -0,0 +1,508 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-bedrock'
+require 'aws-sdk-bedrockruntime'
+require 'legion/json'
+require 'legion/logging'
+require 'legion/settings'
+require 'legion/extensions/llm'
+
+module Legion
+  module Extensions
+    module Llm
+      module Bedrock
+        # Amazon Bedrock provider implementation for the Legion::Extensions::Llm contract.
+        class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
+          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' },
+            { model: 'amazon.titan-embed-text-v2:0', alias: 'titan-embed-text-v2', usage_type: :embedding },
+            { model: 'meta.llama3-2-11b-instruct-v1:0', alias: 'llama-3.2-11b-instruct' },
+            { model: 'mistral.mistral-large-3-675b-instruct', alias: 'mistral-large-3' }
+          ].freeze
+
+          ALIASES = STATIC_MODELS.to_h { |entry| [entry.fetch(:alias), entry.fetch(:model)] }.freeze
+
+          class << self
+            def slug = 'bedrock'
+
+            def configuration_options
+              %i[
+                bedrock_region
+                bedrock_endpoint
+                bedrock_access_key_id
+                bedrock_secret_access_key
+                bedrock_session_token
+                bedrock_profile
+                bedrock_stub_responses
+              ]
+            end
+
+            def configuration_requirements = []
+            def capabilities = Capabilities
+
+            def resolve_model_id(model_id, config: nil) # rubocop:disable Lint/UnusedMethodArgument
+              ALIASES.fetch(model_id.to_s, model_id.to_s)
+            end
+          end
+
+          # Capability predicates inferred from Bedrock model IDs and API modalities.
+          module Capabilities
+            module_function
+
+            def chat?(model) = !embeddings?(model)
+            def streaming?(model) = chat?(model)
+            def vision?(model) = model_id(model).match?(/(claude-3|llama3-2-(11|90)b)/)
+            def functions?(model) = chat?(model)
+            def embeddings?(model) = model_id(model).match?(/embed|embedding/)
+
+            def model_id(model)
+              return model.fetch('model', model.fetch('id', '')) if model.is_a?(Hash)
+
+              model.respond_to?(:id) ? model.id.to_s : model.to_s
+            end
+          end
+
+          def api_base
+            config.bedrock_endpoint || "https://bedrock-runtime.#{region}.amazonaws.com"
+          end
+
+          def completion_url = 'Converse'
+          def stream_url = 'ConverseStream'
+          def models_url = 'ListFoundationModels'
+          def embedding_url(**) = 'InvokeModel'
+          def count_tokens_url = 'CountTokens'
+
+          def region
+            config.bedrock_region || DEFAULT_REGION
+          end
+
+          def discover_offerings(live: false, **filters)
+            return static_offerings(**filters) unless live
+
+            response = bedrock_client.list_foundation_models(**filters)
+            Array(value(response, :model_summaries)).map { |summary| offering_from_summary(summary) }
+          end
+
+          def offering_for(model:, model_family: nil, instance_id: :default, **metadata)
+            model_id = self.class.resolve_model_id(model)
+            build_offering(
+              model: model_id,
+              alias_name: alias_for(model_id),
+              model_family: model_family || model_family_for(model_id),
+              instance_id: instance_id,
+              usage_type: metadata.delete(:usage_type) || usage_type_for(model_id),
+              metadata: metadata
+            )
+          end
+
+          def health(live: false)
+            baseline = {
+              provider: :bedrock,
+              region: region,
+              configured: true,
+              ready: true,
+              live: live,
+              credentials: credential_source
+            }
+            return baseline.merge(checked: false) unless live
+
+            bedrock_client.list_foundation_models
+            baseline.merge(checked: true)
+          rescue StandardError => e
+            baseline.merge(checked: true, ready: false, error: e.class.name, message: e.message)
+          end
+
+          def readiness(live: false)
+            health(live: live).merge(local: false, remote: true, api_base: api_base, endpoints: endpoint_manifest)
+          end
+
+          def list_models
+            discover_offerings(live: true).map do |offering|
+              Legion::Extensions::Llm::Model::Info.new(
+                id: offering.model,
+                name: offering.metadata[:alias] || offering.model,
+                provider: :bedrock,
+                family: offering.metadata[:model_family],
+                capabilities: offering.capabilities.map(&:to_s),
+                metadata: offering.to_h
+              )
+            end
+          end
+
+          def chat(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {})
+            request = Utils.deep_merge(
+              converse_request(messages, model:, temperature:, max_tokens:, tools:, tool_prefs:),
+              params
+            )
+            parse_converse_response(runtime_client.converse(**request), model_id(model))
+          end
+
+          def stream(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {},
+                     &)
+            request = Utils.deep_merge(
+              converse_request(messages, model:, temperature:, max_tokens:, tools:, tool_prefs:),
+              params
+            )
+            stream_converse(request, model_id(model), &)
+          end
+
+          def count_tokens(messages, model:, system: nil, params: {})
+            request = Utils.deep_merge(
+              {
+                model_id: model_id(model),
+                input: { converse: { messages: format_messages(messages), system: system_blocks(system) }.compact }
+              },
+              params
+            )
+            response = runtime_client.count_tokens(**request)
+            { input_tokens: value(response, :input_tokens), raw: normalize_response(response) }
+          end
+
+          def embed(text, model:, dimensions: nil)
+            model_id = model_id(model)
+            unless titan_embed?(model_id)
+              raise NotImplementedError,
+                    "Bedrock embedding payload for #{model_id} is not standardized"
+            end
+
+            body = { inputText: text, dimensions: dimensions }.compact
+            response = runtime_client.invoke_model(
+              model_id: model_id,
+              content_type: 'application/json',
+              accept: 'application/json',
+              body: Legion::JSON.generate(body)
+            )
+            parse_embedding_response(response, model: model_id)
+          end
+
+          def complete(messages, tools:, temperature:, model:, params: {}, schema: nil, thinking: nil, tool_prefs: nil,
+                       &)
+            payload = params.dup
+            payload[:additional_model_request_fields] ||= {}
+            payload[:additional_model_request_fields][:thinking] = thinking if thinking
+            payload[:additional_model_request_fields][:response_format] = schema if schema
+
+            if block_given?
+              stream(messages, model:, temperature:, tools:, tool_prefs:, params: payload, &)
+            else
+              chat(messages, model:, temperature:, tools:, tool_prefs:, params: payload)
+            end
+          end
+
+          private
+
+          def static_offerings(**filters)
+            STATIC_MODELS.filter_map do |entry|
+              provider_filter = normalize_provider(filters[:by_provider])
+              next if provider_filter && model_family_for(entry.fetch(:model)) != provider_filter
+
+              offering_for(**entry.slice(:model, :usage_type))
+            end
+          end
+
+          def offering_from_summary(summary)
+            model = value(summary, :model_id)
+            build_offering(
+              model: model,
+              alias_name: alias_for(model),
+              model_family: normalize_provider(value(summary, :provider_name)) || model_family_for(model),
+              usage_type: usage_type_from_modalities(value(summary, :output_modalities)),
+              capabilities: capabilities_from_summary(summary),
+              metadata: normalize_response(summary)
+            )
+          end
+
+          def build_offering(model:, model_family:, usage_type:, instance_id: :default, alias_name: nil,
+                             capabilities: nil, metadata: {})
+            Legion::Extensions::Llm::Routing::ModelOffering.new(
+              provider_family: :bedrock,
+              instance_id: instance_id,
+              transport: :aws_sdk,
+              tier: :frontier,
+              model: model,
+              usage_type: usage_type,
+              capabilities: capabilities || default_capabilities(model),
+              metadata: metadata.merge(model_family: model_family, alias: alias_name).compact
+            )
+          end
+
+          def converse_request(messages, model:, temperature:, max_tokens:, tools:, tool_prefs:)
+            {
+              model_id: model_id(model),
+              messages: format_messages(messages.reject { |message| message.role == :system }),
+              system: format_system(messages),
+              inference_config: { temperature: temperature, max_tokens: max_tokens || model_max_tokens(model) }.compact,
+              tool_config: format_tool_config(tools, tool_prefs)
+            }.compact
+          end
+
+          def format_messages(messages)
+            messages.map do |message|
+              {
+                role: bedrock_role(message.role),
+                content: content_blocks(message.content)
+              }
+            end
+          end
+
+          def format_system(messages)
+            system_messages = messages.select { |message| message.role == :system }
+            system_text = system_messages.map { |message| content_text(message.content) }
+            system_blocks(system_text.join("\n"))
+          end
+
+          def system_blocks(system)
+            return nil if system.to_s.empty?
+
+            [{ text: system }]
+          end
+
+          def bedrock_role(role)
+            role == :assistant ? 'assistant' : 'user'
+          end
+
+          def content_blocks(content)
+            raw_content(content) || [{ text: content_text(content) }]
+          end
+
+          def raw_content(content)
+            return nil unless content.is_a?(Legion::Extensions::Llm::Content::Raw)
+
+            Array(content.format)
+          end
+
+          def content_text(content)
+            return content.text.to_s if content.respond_to?(:text)
+
+            content.to_s
+          end
+
+          def format_tool_config(tools, tool_prefs)
+            return nil if tools.empty?
+
+            { tools: tools.values.map { |tool| tool_definition(tool) }, tool_choice: tool_choice(tool_prefs) }.compact
+          end
+
+          def tool_definition(tool)
+            {
+              tool_spec: {
+                name: tool.name,
+                description: tool.description,
+                input_schema: { json: tool_schema(tool) }
+              }
+            }
+          end
+
+          def tool_schema(tool)
+            return tool.params_schema if tool.respond_to?(:params_schema) && tool.params_schema
+
+            { type: 'object', properties: {} }
+          end
+
+          def tool_choice(tool_prefs)
+            return nil unless tool_prefs
+
+            choice = tool_prefs[:choice] || tool_prefs['choice']
+            case choice
+            when :auto, 'auto'
+              { auto: {} }
+            when :required, 'required'
+              { any: {} }
+            else
+              { tool: { name: choice.to_s } }
+            end
+          end
+
+          def parse_converse_response(response, fallback_model)
+            output = value(response, :output)
+            message = value(output, :message)
+            usage = value(response, :usage) || {}
+
+            Legion::Extensions::Llm::Message.new(
+              role: :assistant,
+              content: text_from(value(message, :content)),
+              model_id: fallback_model,
+              tool_calls: parse_tool_calls(value(message, :content)),
+              input_tokens: value(usage, :input_tokens),
+              output_tokens: value(usage, :output_tokens),
+              raw: normalize_response(response)
+            )
+          end
+
+          def stream_converse(request, fallback_model)
+            accumulated = +''
+            final_usage = 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?
+
+                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) }
+            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)
+            )
+          end
+
+          def parse_embedding_response(response, model:)
+            body = parse_body(value(response, :body))
+            vectors = body['embedding'] || body['embeddings'] || body.dig('data', 0, 'embedding')
+            Legion::Extensions::Llm::Embedding.new(vectors: vectors, model: model,
+                                                   input_tokens: body['inputTextTokenCount'])
+          end
+
+          def text_from(content)
+            Array(content).filter_map { |block| value(block, :text) }.join
+          end
+
+          def parse_tool_calls(content)
+            calls = Array(content).filter_map { |block| value(block, :tool_use) }
+            return nil if calls.empty?
+
+            calls.to_h do |call|
+              name = value(call, :name)
+              [
+                value(call, :tool_use_id) || name,
+                Legion::Extensions::Llm::ToolCall.new(id: value(call, :tool_use_id) || name, name: name,
+                                                      arguments: value(call, :input) || {})
+              ]
+            end
+          end
+
+          def bedrock_client
+            Aws::Bedrock::Client.new(client_options)
+          end
+
+          def runtime_client
+            Aws::BedrockRuntime::Client.new(client_options)
+          end
+
+          def client_options
+            {
+              region: region,
+              endpoint: config.bedrock_endpoint,
+              credentials: credentials,
+              stub_responses: config.bedrock_stub_responses
+            }.compact
+          end
+
+          def credentials
+            return Aws::SharedCredentials.new(profile_name: config.bedrock_profile) if config.bedrock_profile
+            return nil unless config.bedrock_access_key_id
+
+            Aws::Credentials.new(config.bedrock_access_key_id, config.bedrock_secret_access_key,
+                                 config.bedrock_session_token)
+          end
+
+          def credential_source
+            return :static if config.bedrock_access_key_id
+            return :profile if config.bedrock_profile
+
+            :aws_sdk_default_chain
+          end
+
+          def model_id(model)
+            id = model.respond_to?(:id) ? model.id : model
+            self.class.resolve_model_id(id)
+          end
+
+          def model_max_tokens(model)
+            model.respond_to?(:max_tokens) ? model.max_tokens : nil
+          end
+
+          def usage_type_for(model)
+            titan_embed?(model) ? :embedding : :inference
+          end
+
+          def usage_type_from_modalities(output_modalities)
+            Array(output_modalities).map(&:to_s).include?('EMBEDDING') ? :embedding : :inference
+          end
+
+          def default_capabilities(model)
+            return %i[embedding] if titan_embed?(model)
+
+            capabilities = %i[chat streaming]
+            capabilities << :vision if Capabilities.vision?(model)
+            capabilities << :functions if Capabilities.functions?(model)
+            capabilities
+          end
+
+          def capabilities_from_summary(summary)
+            capabilities = []
+            capabilities << :embedding if usage_type_from_modalities(value(summary, :output_modalities)) == :embedding
+            capabilities << :chat if capabilities.empty?
+            capabilities << :streaming if value(summary, :response_streaming_supported)
+            capabilities << :vision if Array(value(summary, :input_modalities)).map(&:to_s).include?('IMAGE')
+            capabilities
+          end
+
+          def model_family_for(model)
+            normalize_provider(model.to_s.split('.').first)
+          end
+
+          def normalize_provider(provider)
+            value = provider.to_s.downcase.tr(' ', '_').tr('-', '_')
+            return nil if value.empty?
+
+            case value
+            when 'mistral_ai'
+              :mistral
+            else
+              value.to_sym
+            end
+          end
+
+          def titan_embed?(model)
+            model.to_s.include?('titan-embed')
+          end
+
+          def alias_for(model)
+            ALIASES.key(model)
+          end
+
+          def parse_body(body)
+            body = body.read if body.respond_to?(:read)
+            body = body.string if body.respond_to?(:string)
+            body.is_a?(String) ? Legion::JSON.parse(body, symbolize_names: false) : body.to_h
+          end
+
+          def normalize_response(response)
+            response.respond_to?(:to_h) ? response.to_h : {}
+          end
+
+          def value(object, key)
+            return nil if object.nil?
+
+            string_key = key.to_s
+            return object[key] if object.respond_to?(:key?) && object.key?(key)
+            return object[string_key] if object.respond_to?(:key?) && object.key?(string_key)
+            return object.public_send(key) if object.respond_to?(key)
+
+            if object.respond_to?(:to_h)
+              hash = object.to_h
+              return hash[key] if hash.key?(key)
+              return hash[string_key] if hash.key?(string_key)
+            end
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Bedrock
+        VERSION = '0.1.0'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm'
+require 'legion/extensions/llm/bedrock/provider'
+require 'legion/extensions/llm/bedrock/version'
+
+module Legion
+  module Extensions
+    module Llm
+      # Amazon Bedrock provider extension namespace.
+      module Bedrock
+        extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
+
+        PROVIDER_FAMILY = :bedrock
+
+        def self.default_settings
+          ::Legion::Extensions::Llm.provider_settings(
+            family: PROVIDER_FAMILY,
+            discovery: { enabled: false, live: false, regions: %w[us-east-1 us-west-2] },
+            instance: {
+              endpoint: 'https://bedrock-runtime.us-east-1.amazonaws.com',
+              region: 'us-east-1',
+              tier: :frontier,
+              transport: :aws_sdk,
+              credentials: {
+                provider: 'aws-sdk-default-chain',
+                access_key_id: 'env://AWS_ACCESS_KEY_ID',
+                secret_access_key: 'env://AWS_SECRET_ACCESS_KEY',
+                session_token: 'env://AWS_SESSION_TOKEN',
+                profile: 'env://AWS_PROFILE'
+              },
+              usage: { inference: true, embedding: true, token_counting: true },
+              limits: { concurrency: 4 }
+            }
+          )
+        end
+
+        def self.provider_class
+          Provider
+        end
+      end
+    end
+  end
+end
+
+Legion::Extensions::Llm::Provider.register(Legion::Extensions::Llm::Bedrock::PROVIDER_FAMILY,
+                                           Legion::Extensions::Llm::Bedrock::Provider)

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: lex-llm-bedrock
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- LegionIO
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-bedrock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-bedrockruntime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: lex-llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+description: Amazon Bedrock provider integration for the LegionIO LLM routing framework.
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/CODEOWNERS"
+- ".github/dependabot.yml"
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- lex-llm-bedrock.gemspec
+- lib/legion/extensions/llm/bedrock.rb
+- lib/legion/extensions/llm/bedrock/provider.rb
+- lib/legion/extensions/llm/bedrock/version.rb
+homepage: https://github.com/LegionIO/lex-llm-bedrock
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-llm-bedrock
+  source_code_uri: https://github.com/LegionIO/lex-llm-bedrock
+  documentation_uri: https://github.com/LegionIO/lex-llm-bedrock
+  changelog_uri: https://github.com/LegionIO/lex-llm-bedrock/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-llm-bedrock/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LegionIO LLM Amazon Bedrock provider extension
+test_files: []