lex-llm-bedrock 0.5.5 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dff754b7817098396287ff77ec64205f5dea845b43eddd9c73ddb742b8b638c
-  data.tar.gz: 754c16f98e51acfcfaee31bf936741616adb92bacb7042956f278d7ff65f9c66
+  metadata.gz: 860a45a8f5e161e2d46d3822a895dc659136ab19e9f5ad0233f690ec9742a8ae
+  data.tar.gz: f5dac9cdcf27cecc7c7ed319febc79fc3bc390a92eafb3e40e27e768c4cd514f
 SHA512:
-  metadata.gz: 3a674c63e6fd3f99855f89dcbd63319148751ff4dea85596a1cf6024a90d5de015ba35eb8c7bff563143f40608ced83dbda1196794569560c7df79337c545e17
-  data.tar.gz: 645ed19662a6b3097202b494a4ef941f08b7fdc39d8af8feed201fa13b341697736f0b517294b0980d0bad7009dc81f60e6f3ad95abf2987cc4ed36971c1c064
+  metadata.gz: e075da15662be51f02f72286c894ebbc26fa09251f2cb8e62ff09801a5a869947886dbce7e5fa35b6fb9ca08aa2269618af28ff38803bcafc6b53ce579a71b6a
+  data.tar.gz: 8bae12f419ea1f3b6bc13233a98a35ef988e0953a6149c55f419ea8a5a0461c0d00a12b8186061773d732c629efaf40c4658f2f1bd8e59a219262d72e645fc38

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## [0.5.8] - 2026-08-25
+
+### Added
+- **Model-aware adaptive/effort thinking wire** — Claude opus-4-6, opus-4-7, opus-4-8, opus-5, sonnet-4-6, and sonnet-5 on Bedrock now emit `{ type: 'adaptive' }` + `output_config: { effort: <low|medium|high|xhigh|max> }` with the `effort-2025-11-24` beta header, instead of the budgeted `{ type: 'enabled', budget_tokens: N }` shape which these models reject with `ValidationException`. Effort is passed through directly from the canonical `Thinking::Config#resolved_effort` (the full ladder maps 1:1); `none` or nil effort omits `output_config` so the API defaults to high. Both dispatch paths (invoke_model and Converse) emit the correct wire shape based on model classification. Precedence logic ensures `claude-opus-4-7` matches adaptive before `claude-opus-4` matches budgeted.
+
+## [0.5.7] - 2026-08-25
+
+### Fixed
+- **Budget/max_tokens reconciliation** — `ThinkingModes.thinking_wire` now clamps `budget_tokens` so it is strictly less than the effective `max_tokens` sent on the wire (Bedrock constraint: `max_tokens > budget_tokens`). When Codex sends `effort=high` (resolving to `budget_tokens=16384`) but the client's `max_output_tokens` is only 2048, the budget is clamped to `max_tokens - OUTPUT_RESERVE` (floor: 1024) instead of producing an HTTP 400 `ValidationException`. If `max_tokens` is too small to fit even the minimum budget, thinking is omitted to keep the request valid rather than overriding the client's cap.
+- **Removed latent NoMethodError** — Dropped the `|| params&.max_thinking_tokens` fallback in `thinking_wire`; `Canonical::Params#max_thinking_tokens` was deleted in lex-llm 0.8.3 and `&.` does not guard a deleted method on a non-nil receiver. `thinking.resolved_budget` is the sole budget source.
+
+## [0.5.6] - 2026-08-19
+
+### Changed
+- **Canonical dispatch boundary (N x N law)** — The production `BedrockCallable#chat` / `#stream_chat` / `#count_tokens` operations now call `Provider#enforce_canonical_messages!` before dispatch, and the provider's message-conversion seam (`DispatchHelpers#build_provider_messages`) accepts only `Canonical::Message` (pipeline dispatch) or the provider-native `Legion::Extensions::Llm::Message` (Chat facade); anything else raises a loud `ArgumentError`. The lenient message-level hash re-canonicalization that masked the 2026-08-19 hash-bypass defect is removed from the invoke_model render path. Client request formats and the Bedrock wire payload shape are unchanged.
+- **Dependency floor** — Requires `lex-llm >= 0.7.7` for `Provider#enforce_canonical_messages!` (the N x N dispatch boundary). The Gemfile adds a local-tree `lex-llm` path dependency to the test group so the adjacent checkout resolves against 0.7.7 during development.
+
+### Added
+- **Dispatch-boundary regression guards** — The SSOT v3 conformance spec now asserts that plain-Hash messages are rejected loudly at both the callable dispatch boundary and the provider render seam, and the model-policy / streaming specs that previously fed incidental Hash messages now use canonical inputs.
+
+### 0.8.0 conformance (SSOT v4 provider wave, 2026-08-20)
+
+#### Changed
+- **Legacy types migrated to Canonical** — Every provider parse/build path now renders FROM `Canonical::Message` / `Canonical::ContentBlock` and parses TO `Canonical::Response` / `Canonical::Chunk` / `Canonical::ToolCall` / `Canonical::Usage` / `Canonical::Thinking`. The deleted legacy `Llm::Message` / `Llm::Chunk` / `Llm::ToolCall` / `Llm::Content::Raw` / `Llm::Content::ImageAttachment` constructions and the `to_provider_message` re-canonicalization bridge are gone; the provider dispatch seam enforces `Canonical::Message` only.
+- **Callable boundary is the 0.8.0 contract** — `BedrockCallable#chat` / `#stream_chat` take messages positionally, matching the base `Provider#chat` signature and the fleet `WorkerExecution` dispatch. The `enforce_canonical_messages!` calls (the one shared lex-llm helper at the exact-execution boundary) and `normalize_dispatch_error(error:)` are kept.
+- **Offering read path (07 C5)** — The legacy `Routing::ModelOffering` production chain in the provider (`discover_offerings` override, `offering_for`, `offering_from_model`, `offering_from_summary`, `build_offering`, `static_offerings` and their filter helpers) is deleted; the base `Provider#discover_offerings` serves the activated inventory offerings from `Registry.snapshot`. The discovery actor's `OfferingDraft` writer path is the sole publication path.
+- **Streaming is canonical end-to-end** — Both streaming paths (Converse events and invoke_model Anthropic events) yield `Canonical::Chunk` objects (`text_delta` / `thinking_delta` / `tool_call_delta`) and the sequence ends in exactly one `done` chunk carrying usage + stop_reason; the accumulated state builds a `Canonical::Response`. Tool-input JSON fragments travel on the `tool_call_delta` chunk and are parsed once at stream end.
+- **Sync parse boundary** — The Converse and invoke_model sync parsers delegate to the gem's canonical `Translator` (one parse boundary); the `content_filtered` / `content_filter` wire stop-reason spellings map to canonical `:content_filter` at that single edge.
+- **Embed artifact (05 §3 / O07)** — `parse_embedding_response` returns the documented Hash artifact `{ text:, model:, embedding:, usage: Canonical::Usage }` (the deleted `Llm::Embedding` type is gone).
+
+#### Removed
+- **Legacy coordinator wiring** — The `ScopedRefresher::LegacyCoordinatorAdapter` compatibility adapter (and the `scoped_refresher` require) is removed from the discovery actor's `Publisher` construction; the mixed-version window is over with the lex-llm 0.8.0 cut.
+
+#### Added
+- **Conformance kit B1/B2** — The SSOT v3 conformance spec now loads the 0.8.0 boundary kit (`ssot_contract_examples.rb`) and runs the B1 (central canonical enforcement) and B2 (canonical outputs) shared example groups against the real `BedrockCallable` -> `Bedrock::Provider` -> stubbed-AWS-SDK boundary.
+- **RULES.md** — The 0.8.0 architecture law (`references/01-rules-draft.md`, byte-for-byte) ships at the repo root.
+
+#### Dependency
+- **Floor bump** — Requires `lex-llm >= 0.8.0` (the contract cut: canonical strictification, legacy rip, provider funnel, fleet v3, conformance kit).
+
 ## [0.5.5] - 2026-08-19
 
 ### Added

data/Gemfile

@@ -2,10 +2,15 @@
 
 source 'https://rubygems.org'
 
-gem 'lex-llm'
-
 gemspec
 
+# Local-tree resolution: use the adjacent lex-llm checkout when present so the
+# canonical-boundary work resolves against the unreleased 0.7.7.
+group :test do
+  lex_llm_path = File.expand_path('../lex-llm', __dir__)
+  gem 'lex-llm', path: lex_llm_path if Dir.exist?(lex_llm_path)
+end
+
 group :development do
   gem 'bundler', '>= 2.0'
   gem 'rake', '>= 13.0'

data/RULES.md

@@ -0,0 +1,97 @@
+RULES.md — Legion LLM Architecture Law
+These rules apply to every task, file, repository, agent, model, session, test, refactor, migration, incident, and release.
+The requested task defines what may change. These rules define how the system ALWAYS works.
+Every rule remains active 100% of the time. If requested work conflicts with these rules, stop and surface the conflict before changing code.
+These are architecture laws. Scope, compatibility, urgency, convenience, tests, existing behavior, and model judgment do not change them.
+1. Canonical is the only internal language.
+Every client translates client wire -> Canonical before shared execution.
+Shared execution carries Canonical through context, tools, routing, direct dispatch, fleet dispatch, and response handling.
+Every provider translates Canonical -> provider wire at the provider boundary, then provider wire -> Canonical before returning to shared execution.
+Every internal boundary validates the Canonical type it is defined to receive and raises immediately when that contract is violated.
+Client Wire -> Client Translator -> Canonical -> Shared Execution -> Canonical -> Provider Translator -> Provider Wire.
+2. Serialization preserves Canonical.
+Transport may serialize Canonical state. The receiving transport boundary ALWAYS rehydrates the exact Canonical type before execution continues.
+Fleet follows Canonical -> serialize -> wire -> deserialize -> rehydrate Canonical -> Canonical.
+Serialization changes encoding only. Ownership, identity, model, operation, capability, selection, and meaning remain exactly the same.
+After rehydration, shared execution continues only with Canonical objects.
+3. Every authoritative fact has exactly one owner.
+The owner creates the fact once. Every downstream layer carries, projects, serializes, rehydrates, verifies, or executes that exact fact.
+A downstream layer receiving missing or contradictory authoritative state raises and returns the defect to the owning layer.
+Authority ALWAYS moves forward by preservation.
+Authority is created once and is never recreated downstream.
+4. Requirements describe the request. Inventory describes reality. Router chooses. Dispatch executes.
+Canonical request construction owns request semantics. RequestRequirements expresses operation, capabilities, modality, context, output, tools, and explicit pins.
+Providers publish exact executable facts into Inventory. Inventory owns canonical instance, offering, lane, capability, context, quota, health, and published weight state.
+Router.next_lane consumes Requirements plus one immutable Inventory snapshot and produces one authoritative Selection.
+Dispatch executes that Selection exactly. Once Selection exists, routing is finished.
+5. Inventory facts are immutable executable facts.
+Providers publish exact instances and complete offering snapshots through the Inventory publication contract.
+Identity, capability evidence, context evidence, quota domains, availability, and write-time weights are consumed from published Inventory state.
+A changed fact becomes authoritative only through the owning publication or reconciliation path and a new Inventory snapshot.
+Routing reads Inventory. Dispatch verifies and executes Inventory-backed Selection.
+6. Identity, capabilities, weights, and context policy retain exact ownership.
+Inventory::Identity owns instance, offering, and lane identity; canonical instance identity is provider family plus the operator/configured instance name; physical endpoint data remains secondary.
+Providers publish capability evidence. Requirements state required capabilities. Candidate evaluation compares the two and determines capability eligibility.
+The weight owner computes lane weight at publication time; Inventory stores it; ranking consumes that stored weight; a stored zero disables the lane.
+Preferred-context binning orders eligible candidates into preference bands and preserves eligibility. Capability, health, binning, and weight ALWAYS retain distinct meanings.
+7. Routing chooses exactly once.
+Router.next_lane is the sole routing authority.
+Candidate evaluation determines eligibility from Requirements and Inventory. Ranking orders eligible candidates from published routing facts.
+Selection freezes the exact provider, instance, offering, lane, model, operation, and routing identity required for execution.
+Every downstream component consumes the Selection it receives.
+Selection is preserved, not reconstructed.
+8. Exact execution stays exact through every boundary.
+Direct dispatch executes the exact Selection-derived binding it receives.
+Fleet dispatch serializes and signs that exact binding; fleet validation verifies it; fleet rehydration restores it; worker resolution verifies it against authoritative Inventory.
+The selected provider, instance, offering, lane, model, and operation remain identical through projection, signing, transport, validation, rehydration, resolution, and callable invocation.
+A mismatch raises before provider execution.
+An exact execution request ALWAYS remains exact execution.
+9. Health and errors preserve one authoritative meaning.
+Inventory owns exact-instance availability. An authoritative instance-unavailable result removes that exact instance; readiness probing owns recovery; successful readiness republish re-admits it.
+Overload, timeout, rate limit, model-not-ready, and transient provider failures remain request-local according to ProviderOutcome semantics.
+The first layer that can authoritatively classify an error performs that classification once. Every downstream layer preserves it.
+Programming errors remain programming errors. Contract violations remain contract violations. Routing exhaustion remains the defined typed Rejection.
+10. Compatibility exists only at explicit edges.
+Supported legacy clients and protocols are translated into the current Canonical and SSOT architecture at explicit compatibility boundaries.
+Shared execution remains Canonical. Routing remains SSOT-driven. Exact execution remains exact.
+Compatibility code adapts an external contract to the current internal architecture.
+The current internal architecture ALWAYS has one representation, one routing authority, one identity system, and one execution truth.
+11. Fix every defect at its owner.
+Trace the incorrect value to the layer that owns it, then fix that owner.
+Fix client wire in the client translator; Canonical shape in Canonical construction; Requirements in Requirements construction; provider facts in publication; identity in Inventory identity; weights in publication/reconciliation.
+Fix eligibility in candidate evaluation; ordering in ranking; choice in Router.next_lane; execution preservation in dispatch; provider wire in the provider translator.
+The layer where a defect becomes visible is evidence. The owning layer is where the correction belongs.
+12. A discovered issue remains in its owning domain.
+Complete the requested task inside its stated scope.
+When investigation exposes a separate defect owned by another architectural domain, record and surface it as separate work unless the requested task is explicitly expanded.
+Routing work consumes existing Canonical Requirements and Inventory facts. Canonical work changes Canonical contracts. Provider work changes publication or translation. Transport work changes transport.
+Nearby code never changes ownership. “While we are here” never changes architecture.
+13. N x N ALWAYS converges through Canonical.
+Equivalent client semantics produce equivalent Canonical state before shared execution. Every provider consumes the same Canonical semantics for the same request.
+When two paths disagree, capture the state at every involved boundary and locate the FIRST point where Canonical meaning diverges.
+Fix that first divergent boundary, then run the exact failing path again.
+Client behavior is proven at client-wire <-> Canonical. Provider behavior is proven at Canonical <-> provider-wire. Shared execution is proven with Canonical throughout.
+14. Debug from captured authoritative state.
+Capture the actual input at the failing boundary before reasoning from symptoms.
+For translation or transport defects, capture Canonical immediately before and after every involved boundary.
+For routing or dispatch defects, capture Requirements, relevant Inventory facts, Selection, execution binding, and ProviderOutcome.
+Compare each captured value to the contract owned by that layer. Find the first divergence. Fix its owner. Re-run the exact path.
+Then inspect sibling implementations for the same defect class.
+15. Tests prove the real boundary and the invariant.
+A boundary test exercises the real boundary it claims to protect.
+Fleet tests exercise real serialization, deserialization, Canonical rehydration, signing, validation, exact resolution, and callable dispatch.
+Provider tests exercise the real callable boundary and provider translator. Routing tests exercise real Requirements, Inventory records, candidate evaluation, ranking, and Selection.
+Regression tests prove the violated invariant, not only the observed symptom.
+A green suite is release evidence only when the tested path traverses the real architecture.
+16. Shared contracts are consumed directly.
+Shared Canonical types own execution representation. Shared Inventory types own inventory state. Shared Routing types own routing state.
+Shared taxonomy owns canonical mappings. Shared ProviderOutcome owns provider-neutral outcomes. Shared fleet protocol owns exact execution claims.
+Every repository consumes these shared owners directly.
+A defect in one shared boundary triggers an audit of every sibling implementation of that boundary. Fix the shared owner centrally whenever the defect belongs to a shared contract.
+17. Architecture is the release gate.
+Every change preserves every rule in this file.
+Tests, compatibility, historical behavior, migration phase, patch urgency, nearby code, task wording, and model judgment are evaluated UNDER these rules.
+A contradiction between existing behavior and these rules is surfaced as an architecture conflict and resolved at the owning boundary before release.
+Limited scope means do less. Limited scope NEVER means fewer rules apply.
+These rules apply 100% of the time.
+These are the law.

data/lex-llm-bedrock.gemspec

@@ -29,5 +29,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.4.2'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.7.6'
+  # 0.8.0 is the contract cut: canonical-only dispatch boundary (the legacy
+  # Llm::Message/Chunk/ToolCall/Content types and the ScopedRefresher
+  # adapter wiring are deleted), Registry-snapshot offering read path,
+  # and the conformance kit this gem runs against.
+  spec.add_dependency 'lex-llm', '>= 0.8.0'
 end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/discovery/actor'
+
+# The base discovery actor only exists inside the daemon (it inherits the
+# LegionIO time-based Every actor). In a standalone load, define nothing.
+return unless defined?(Legion::Extensions::Llm::Discovery::Actor)
+
+module Legion
+  module Extensions
+    module Llm
+      module Bedrock
+        module Actor
+          # Bedrock discovery actor: an EMPTY subclass of the shared base. The
+          # timer, dispatch, and runner-resolution convention are inherited —
+          # this class redefines nothing. The Bedrock-specific work lives in
+          # Bedrock::Runners::Discovery, resolved by the base from this
+          # namespace.
+          class Discovery < Legion::Extensions::Llm::Discovery::Actor; end
+        end
+      end
+    end
+  end
+end

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

@@ -65,13 +65,10 @@ module Legion
             settings = CredentialSources.setting(:extensions, :llm, :bedrock)
             return unless settings.is_a?(Hash) && !settings.empty?
 
-            default_config = dedup_config(normalize_instance_config(settings))
-            unless default_config.empty?
-              default_config[:source] = CredentialSources.source_tag(:settings, 'extensions.llm.bedrock')
-              default_config[:credential_fingerprint] = CredentialSources.config_fingerprint(default_config)
-              candidates[:settings] = default_config.merge(tier: :cloud)
-            end
-
+            # B15: operator-named instances are collected before the
+            # top-level :settings (source-named) candidate — with first-wins
+            # dedup, the operator's instance keeps its name over the
+            # source-named fallback carrying the same credentials.
             settings_instances(settings).each do |name, config|
               next unless config.is_a?(Hash)
 
@@ -81,6 +78,13 @@ module Legion
               normalized[:credential_fingerprint] = CredentialSources.config_fingerprint(normalized)
               candidates[name.to_sym] = normalized.merge(tier: :cloud)
             end
+
+            default_config = dedup_config(normalize_instance_config(settings))
+            return if default_config.empty?
+
+            default_config[:source] = CredentialSources.source_tag(:settings, 'extensions.llm.bedrock')
+            default_config[:credential_fingerprint] = CredentialSources.config_fingerprint(default_config)
+            candidates[:settings] = default_config.merge(tier: :cloud)
           end
 
           def discover_broker(candidates)

data/lib/legion/extensions/llm/bedrock/{callable.rb → helpers/callable.rb}

@@ -10,17 +10,33 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
-        module Actor
+        module Helpers
           # Per-instance dispatch callable for a Bedrock provider instance.
           #
           # Wraps a per-instance Bedrock::Provider built from the instance
-          # config and implements the fleet dispatch operations the coordinator
-          # invokes (chat, stream_chat, embed, count_tokens) with ** passthrough,
-          # plus the disconnect / normalize_dispatch_error(error:) contracts
+          # config and implements the 0.8.0 fleet dispatch operations the
+          # coordinator invokes (chat, stream_chat, embed, count_tokens) plus
+          # the disconnect / normalize_dispatch_error(error:) contracts
           # required by Inventory::CallableHandle and Routing::ProviderOutcome.
+          #
+          # 0.8.0 callable boundary (WorkerExecution.dispatch_operation):
+          # chat/stream_chat take messages POSITIONALLY (base Provider#chat
+          # form); count_tokens takes the messages: kwarg. temperature and
+          # max_tokens are Canonical::Params members (05 O4), never named
+          # completion keys — the folded wire params become a Canonical::Params
+          # at this boundary, because the 0.8.0 renderer reads params.temperature
+          # / params.max_tokens (a raw Hash would NoMethodError).
           # Provider and AWS SDK errors propagate unchanged so
           # normalize_dispatch_error can classify them.
-          class BedrockCallable
+          class Callable
+            # Keys the base Provider exposes as named kwargs for the completion
+            # operations. Anything else the fleet passes (sampling scalars,
+            # `temperature` — a Canonical::Params member, 05 O4) is folded into
+            # Canonical::Params at the dispatch boundary.
+            COMPLETION_NAMED_KEYS = %i[tools tool_prefs thinking].freeze
+            COUNT_TOKENS_NAMED_KEYS = %i[system].freeze
+            EMBED_NAMED_KEYS = %i[dimensions].freeze
+
             def initialize(instance_cfg:, logger:)
               @instance_cfg = instance_cfg
               @logger = logger
@@ -45,41 +61,58 @@ module Legion
               @logger.debug { '[bedrock][callable] disconnected' }
             end
 
-            def chat(messages:, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil,
-                     thinking: nil, params: {}, **opts)
+            def chat(messages, model:, **rest)
               dispatch! do
-                provider.chat(messages: messages, model: model, temperature: temperature, max_tokens: max_tokens,
-                              tools: tools, tool_prefs: tool_prefs, thinking: thinking, params: params.merge(opts))
+                # Canonical boundary (N x N law): pipeline dispatch delivers
+                # Canonical::Message objects only. Hash/legacy shapes are the
+                # bypass class — reject loudly, never coerce.
+                provider.enforce_canonical_messages!(messages)
+                named, params = split_fleet_kwargs(rest, COMPLETION_NAMED_KEYS)
+                provider.chat(messages: messages, model: model, params: canonical_params(params), **named)
               end
             end
 
-            def stream_chat(messages:, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil,
-                            thinking: nil, params: {}, **opts, &)
+            def stream_chat(messages, model:, **rest, &)
               dispatch! do
-                provider.stream(messages: messages, model: model, temperature: temperature, max_tokens: max_tokens,
-                                tools: tools, tool_prefs: tool_prefs, thinking: thinking,
-                                params: params.merge(opts), &)
+                provider.enforce_canonical_messages!(messages)
+                named, params = split_fleet_kwargs(rest, COMPLETION_NAMED_KEYS)
+                provider.stream(messages: messages, model: model, params: canonical_params(params), **named, &)
               end
             end
 
-            def embed(text:, model:, dimensions: nil, params: {}, **opts)
-              dispatch! { provider.embed(text: text, model: model, dimensions: dimensions, params: params.merge(opts)) }
+            # B19: unowned fleet params are not forwarded — the exact
+            # execution binding carries no payload the operation does not own
+            # (the old params passthrough reached the InvokeModel body
+            # silently). Only the operation's named keys cross the boundary.
+            def embed(text:, model:, **rest)
+              dispatch! do
+                named, _params = split_fleet_kwargs(rest, EMBED_NAMED_KEYS)
+                provider.embed(text: text, model: model, **named)
+              end
             end
 
-            def count_tokens(messages:, model:, system: nil, params: {}, **opts)
+            # The fleet WorkerExecution calls count_tokens with the messages:
+            # KWARG (worker_execution.rb) — only chat/stream_chat are positional.
+            def count_tokens(messages:, model:, **rest)
               dispatch! do
-                provider.count_tokens(messages: messages, model: model, system: system, params: params.merge(opts))
+                provider.enforce_canonical_messages!(messages)
+                named, _params = split_fleet_kwargs(rest, COUNT_TOKENS_NAMED_KEYS)
+                provider.count_tokens(messages: messages, model: model, **named)
               end
             end
 
             def normalize_dispatch_error(error:)
-              reason = error.message.to_s[0, 512]
+              # B9: the base reason policy (10 §1E) — the bounded exception
+              # CLASS NAME; never a response body, credential, endpoint, or
+              # exception message (AWS SDK messages embed request context).
+              reason = error.class.name
+              reason = 'UnknownError' if reason.nil? || reason.empty?
 
               kind = classify_error(error: error)
 
               Legion::Extensions::Llm::Routing::ProviderOutcome.new(
                 kind: kind,
-                reason: reason.empty? ? 'unknown dispatch error' : reason
+                reason:
               )
             end
 
@@ -91,6 +124,25 @@ module Legion
               @provider ||= Legion::Extensions::Llm::Bedrock::Provider.new(@instance_cfg)
             end
 
+            # The 0.8.0 completion funnel receives canonical values only
+            # (08 F3): the folded wire params become a Canonical::Params at the
+            # dispatch boundary — temperature is a params member (05 O4), never
+            # a kwarg. from_hash accepts canonical keys and folds unknowns into
+            # the metadata member (04 L5) — nothing is dropped.
+            def canonical_params(params)
+              Legion::Extensions::Llm::Canonical::Params.from_hash(params)
+            end
+
+            # Split the fleet's **rest into the provider's named completion
+            # kwargs and a payload params hash (any passed :params merged with
+            # the remaining unknown keys).
+            def split_fleet_kwargs(rest, named_keys)
+              named = rest.slice(*named_keys)
+              extra = rest.reject { |key, _| named.key?(key) }
+              params = (extra.delete(:params) || {}).to_h.merge(extra)
+              [named, params]
+            end
+
             def dispatch!
               if disconnected?
                 raise Legion::Extensions::Llm::Inventory::Errors::CallableDisposedError,

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

@@ -30,10 +30,6 @@ module Legion
             def configuration_requirements = []
             def capabilities = Capabilities
 
-            def registry_publisher
-              Legion::Extensions::Llm::Bedrock.registry_publisher
-            end
-
             def resolve_model_id(model_id, **)
               ALIASES.fetch(model_id.to_s, model_id.to_s)
             end

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

@@ -65,11 +65,19 @@ module Legion
               :aws_sdk_default_chain
             end
 
-            def parse_embedding_response(response, model:)
+            # Non-conversation artifact (05 §3, O07): a documented Hash shape,
+            # not a canonical type.
+            def parse_embedding_response(response, model:, text:)
               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'])
+              {
+                text:,
+                model:,
+                embedding: vectors,
+                usage: Legion::Extensions::Llm::Canonical::Usage.build(
+                  input_tokens: body['inputTextTokenCount']
+                )
+              }
             end
 
             def parse_body(body)
@@ -120,10 +128,6 @@ module Legion
             rescue NameError
               nil
             end
-
-            def safe_event_data(evt)
-              evt.respond_to?(:to_h) ? evt.to_h : evt.inspect[0, 500]
-            end
           end
         end
       end