ocai-bedrock 0.1.1__tar.gz

ocai_bedrock-0.1.1/.gitignore

@@ -0,0 +1,60 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+*.so
+
+# uv / venv
+.venv/
+uv.lock.bak
+
+# Tooling caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.import_linter_cache/
+.coverage
+htmlcov/
+
+# Docs site build output and page cache (zensical build)
+/site/
+/.cache/
+
+# Node (future typescript/)
+node_modules/
+*.tsbuildinfo
+
+# Go (future go/)
+/go/bin/
+
+# Editors / OS. Shared editor settings ARE committed: the multi-root workspace
+# (ocai.code-workspace) and each folder's .vscode/settings.json + extensions.json
+# give Pylance/Ruff the right interpreter per project. Personal files stay local.
+.idea/
+.vscode/*
+!.vscode/settings.json
+!.vscode/extensions.json
+.DS_Store
+
+# Per-user agent settings (never commit personal permissions)
+.claude/settings.local.json
+.codex/config.toml
+
+# Platform build and browser-test artifacts
+.nuxt/
+.output/
+platform/test-results/
+platform/playwright-report/
+
+# Local environment files: the root .env is the active one, .envs/ holds the
+# per-environment variants (`task env -- <ENV>` copies .envs/.env.<ENV> to .env).
+# Never committed: they hold credentials.
+/.env
+/.envs/
+.local/
+
+# Task execution fingerprints
+.task/

ocai_bedrock-0.1.1/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to ocai-bedrock are recorded here by the release workflow.
+## 0.1.1 (2026-11-11)
+
+### Features
+
+#### Add an explicit Bedrock InvokeModel host for Anthropic unary calls, native errors,
+
+and governed host metadata/guardrail effects through public ocai contracts. Keep
+AWS authentication in ocai-aws and semantic conversion in ocai-anthropic (WU-48).
+
+Strengthen package boundary checks for the independent cloud service adapter;
+no kernel runtime or canonical contract changes.

ocai_bedrock-0.1.1/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.5
+Name: ocai-bedrock
+Version: 0.1.1
+Summary: Bedrock hosting through public ocai contracts.
+Project-URL: Homepage, https://github.com/ocarinow/ocai
+Project-URL: Source, https://github.com/ocarinow/ocai
+Project-URL: Documentation, https://ocarinow.github.io/ocai/
+Project-URL: Changelog, https://github.com/ocarinow/ocai/blob/main/python/packages/ocai-bedrock/CHANGELOG.md
+Author: ocai maintainers
+License-Expression: FSL-1.1-ALv2
+Requires-Python: >=3.13
+Requires-Dist: ocai<0.2,>=0.1
+Provides-Extra: anthropic
+Requires-Dist: ocai-anthropic<0.2,>=0.1; extra == 'anthropic'
+Provides-Extra: aws
+Requires-Dist: ocai-aws<0.2,>=0.1; extra == 'aws'
+Description-Content-Type: text/markdown
+
+# ocai-bedrock
+
+Bedrock hosting for ocai, separate from shared AWS authentication and semantic
+provider codecs. This package owns InvokeModel addressing, native host errors and
+response metadata/effects. It performs no discovery and imports no provider SDK.
+
+```python
+import ocai.chat
+from ocai.aws import SigV4Credential
+from ocai.bedrock import Bedrock
+
+model = ocai.chat.model(
+    "anthropic/us.anthropic.claude-3-5-sonnet-20241022-v2:0",
+    host=Bedrock(region="us-east-1"),
+    credentials=SigV4Credential(
+        access_key="synthetic-access-key", secret_key="synthetic-secret-key",
+        region="us-east-1",
+    ),
+)
+```
+
+Install the Anthropic codec and AWS credential packages separately or use the
+`anthropic` and `aws` extras. The application supplies credentials explicitly;
+ocai-aws delegates signing to AWS-maintained code. Users do not import its SDK.
+
+Qualified unary surface: text, function tools, trait-declared version/beta body
+placement, encoded identifiers, native errors and response metadata/guardrail
+accounting. Explicit profile aliases affect capability lookup only. No model-ID
+heuristic is used. Existing preflight profiles include dialect-wide wildcard
+declarations; those and coverage_complete are not hosted-model qualification
+(G-15). Verify deployment support independently of dialect declarations.
+
+`beta` is an explicit tuple of body beta values; it does not silently enable any
+feature. Version/beta conflicts fail before I/O. Binding-level arbitrary headers
+are transmitted as explicit caller data, not qualified as feature relocations.
+Use the host's beta field or trait-declared feature mappings for that purpose.
+
+Configure guardrail identifier/version together. Recognized trace assessments
+separate blocked output (ContentFilterError) from masking (reported semantic
+shift). An intervention without sufficient trace is reported as unclassified;
+it is never guessed to be blocked or unmodified. FidelityPolicy can reject those
+shifts. HostEvidence retains native headers/body and host metadata; traces can
+contain original content, so application exporters must redact them. Passive
+observers omit this evidence.
+
+Streaming, Converse, media, managed prompts, regional discovery and compatibility
+endpoints are not qualified here. Streaming fails before I/O. Recorded tests prove
+wire behavior without live keys; they do not establish service/account access.
+
+| Surface | Recorded qualification |
+|---|---|
+| Text and system instruction | Exact body, canonical text/finish and input/output usage, both drivers |
+| Function tools | Custom tool schema, auto selection, returned call identity/arguments and finish |
+| Routing and beta | Encoded identifier, explicit version and beta placement; no beta feature availability claim |
+| Errors | Header-only throttle/access/model error and body native codes; unknown codes preserved |
+| Guardrails | Explicit blocking, output masking, uncertain intervention, caller fidelity rejection |
+| Metadata | Host body fields and latency/tier headers retained; future host/dialect fields separated |
+| Excluded | Streaming, Converse, media, managed prompts, regional/model discovery, live availability |
+
+The recordings are synthetic, hand-authored against the AWS research sources in
+`docs/providers/amazon-bedrock.md` section 16. They reuse the existing Anthropic
+conversion graph. There is no new semantic edge or canonical revision.

ocai_bedrock-0.1.1/README.md

@@ -0,0 +1,62 @@
+# ocai-bedrock
+
+Bedrock hosting for ocai, separate from shared AWS authentication and semantic
+provider codecs. This package owns InvokeModel addressing, native host errors and
+response metadata/effects. It performs no discovery and imports no provider SDK.
+
+```python
+import ocai.chat
+from ocai.aws import SigV4Credential
+from ocai.bedrock import Bedrock
+
+model = ocai.chat.model(
+    "anthropic/us.anthropic.claude-3-5-sonnet-20241022-v2:0",
+    host=Bedrock(region="us-east-1"),
+    credentials=SigV4Credential(
+        access_key="synthetic-access-key", secret_key="synthetic-secret-key",
+        region="us-east-1",
+    ),
+)
+```
+
+Install the Anthropic codec and AWS credential packages separately or use the
+`anthropic` and `aws` extras. The application supplies credentials explicitly;
+ocai-aws delegates signing to AWS-maintained code. Users do not import its SDK.
+
+Qualified unary surface: text, function tools, trait-declared version/beta body
+placement, encoded identifiers, native errors and response metadata/guardrail
+accounting. Explicit profile aliases affect capability lookup only. No model-ID
+heuristic is used. Existing preflight profiles include dialect-wide wildcard
+declarations; those and coverage_complete are not hosted-model qualification
+(G-15). Verify deployment support independently of dialect declarations.
+
+`beta` is an explicit tuple of body beta values; it does not silently enable any
+feature. Version/beta conflicts fail before I/O. Binding-level arbitrary headers
+are transmitted as explicit caller data, not qualified as feature relocations.
+Use the host's beta field or trait-declared feature mappings for that purpose.
+
+Configure guardrail identifier/version together. Recognized trace assessments
+separate blocked output (ContentFilterError) from masking (reported semantic
+shift). An intervention without sufficient trace is reported as unclassified;
+it is never guessed to be blocked or unmodified. FidelityPolicy can reject those
+shifts. HostEvidence retains native headers/body and host metadata; traces can
+contain original content, so application exporters must redact them. Passive
+observers omit this evidence.
+
+Streaming, Converse, media, managed prompts, regional discovery and compatibility
+endpoints are not qualified here. Streaming fails before I/O. Recorded tests prove
+wire behavior without live keys; they do not establish service/account access.
+
+| Surface | Recorded qualification |
+|---|---|
+| Text and system instruction | Exact body, canonical text/finish and input/output usage, both drivers |
+| Function tools | Custom tool schema, auto selection, returned call identity/arguments and finish |
+| Routing and beta | Encoded identifier, explicit version and beta placement; no beta feature availability claim |
+| Errors | Header-only throttle/access/model error and body native codes; unknown codes preserved |
+| Guardrails | Explicit blocking, output masking, uncertain intervention, caller fidelity rejection |
+| Metadata | Host body fields and latency/tier headers retained; future host/dialect fields separated |
+| Excluded | Streaming, Converse, media, managed prompts, regional/model discovery, live availability |
+
+The recordings are synthetic, hand-authored against the AWS research sources in
+`docs/providers/amazon-bedrock.md` section 16. They reuse the existing Anthropic
+conversion graph. There is no new semantic edge or canonical revision.

ocai_bedrock-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ocai-bedrock"
+version = "0.1.1"
+description = "Bedrock hosting through public ocai contracts."
+readme = "README.md"
+requires-python = ">=3.13"
+license = "FSL-1.1-ALv2"
+authors = [{ name = "ocai maintainers" }]
+dependencies = ["ocai>=0.1,<0.2"]
+
+[project.optional-dependencies]
+aws = ["ocai-aws>=0.1,<0.2"]
+anthropic = ["ocai-anthropic>=0.1,<0.2"]
+
+[project.urls]
+Homepage = "https://github.com/ocarinow/ocai"
+Source = "https://github.com/ocarinow/ocai"
+Documentation = "https://ocarinow.github.io/ocai/"
+Changelog = "https://github.com/ocarinow/ocai/blob/main/python/packages/ocai-bedrock/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ocai"]
+
+[tool.hatch.build]
+dev-mode-dirs = ["src"]
+
+[tool.ocai]
+role = "host"

ocai_bedrock-0.1.1/src/ocai/bedrock/__init__.py

@@ -0,0 +1,5 @@
+"""Bedrock hosting for ocai; credentials and semantic codecs are separate packages."""
+
+from ocai.bedrock.hosting import Bedrock
+
+__all__ = ["Bedrock"]

ocai_bedrock-0.1.1/src/ocai/bedrock/hosting.py

@@ -0,0 +1,163 @@
+"""External Bedrock hosting; semantic codecs and AWS authentication stay separate."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+from copy import deepcopy
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Any
+
+from ocai.bedrock.outcomes import error_mapping
+from ocai.bedrock.outcomes import response_mapping
+from ocai.core import UnsupportedFeatureError
+from ocai.wire.hosting import Custom
+from ocai.wire.hosting import EndpointSpec
+from ocai.wire.hosting import EnvelopeTransform
+from ocai.wire.outcomes import HostErrorMapper
+from ocai.wire.outcomes import HostResponseAdapter
+
+
+@dataclass(frozen=True)
+class _InvokeEnvelope:
+    spec: EndpointSpec
+    beta: tuple[str, ...]
+    guardrail_config: Mapping[str, Any] | None
+
+    def wrap(self, payload: dict[str, Any]) -> dict[str, Any]:
+        result = deepcopy(payload)
+        if result.get("stream"):
+            raise UnsupportedFeatureError("Bedrock streaming is not qualified yet")
+        if "model" in result and result["model"] != self.spec.resource:
+            raise ValueError("payload model conflicts with the endpoint resource")
+        result.pop("model", None)
+        result.pop("stream", None)
+        additions: dict[str, Any] = dict(self.spec.traits.body_fields("bedrock"))
+        if self.beta:
+            if "anthropic_beta" in additions and additions["anthropic_beta"] != list(self.beta):
+                raise ValueError("conflicting Bedrock beta declarations")
+            additions["anthropic_beta"] = list(self.beta)
+        if self.guardrail_config is not None:
+            additions["amazon-bedrock-guardrailConfig"] = deepcopy(dict(self.guardrail_config))
+        for key, value in additions.items():
+            if key in result and result[key] != value:
+                raise ValueError(f"conflicting Bedrock body declaration: {key}")
+            result[key] = value
+        return result
+
+    def unwrap(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return payload
+
+
+@dataclass(frozen=True)
+class Bedrock:
+    """Host the qualified Anthropic Messages unary surface on InvokeModel.
+
+    Region and credentials are explicit; this value performs no discovery or I/O.
+    Pass it to ocai.chat.model with a separately supplied ocai credential. Optional
+    endpoint_url is explicit deployment configuration, not a discovery mechanism.
+    """
+
+    region: str
+    endpoint_url: str | None = None
+    beta: tuple[str, ...] = ()
+    guardrail_identifier: str | None = None
+    guardrail_version: str | None = None
+    guardrail_config: Mapping[str, Any] | None = None
+    trace: str | None = None
+    performance_latency: str | None = None
+    service_tier: str | None = None
+    static_headers: Mapping[str, str] = field(default_factory=dict[str, str])
+    profile_aliases: Mapping[str, str] = field(default_factory=dict[str, str])
+
+    def __post_init__(self) -> None:
+        """Validate explicit configuration and detach caller-owned maps."""
+        if not re.fullmatch(r"[a-z]{2}(?:-[a-z0-9]+)+-[0-9]+", self.region):
+            raise ValueError("an explicit AWS region name is required")
+        if (self.guardrail_identifier is None) != (self.guardrail_version is None):
+            raise ValueError("guardrail identifier and version must be supplied together")
+        if self.guardrail_config is not None and self.guardrail_identifier is None:
+            raise ValueError("guardrail body configuration requires identifier and version")
+        if any(
+            key.lower() in {"anthropic-version", "anthropic-beta"} for key in self.static_headers
+        ):
+            raise ValueError("use declared body versions and beta, not static Anthropic headers")
+        object.__setattr__(self, "beta", tuple(self.beta))
+        object.__setattr__(self, "static_headers", dict(self.static_headers))
+        object.__setattr__(self, "profile_aliases", dict(self.profile_aliases))
+        object.__setattr__(self, "guardrail_config", deepcopy(self.guardrail_config))
+        self._target()
+
+    def _target(self) -> Custom:
+        suffix = "amazonaws.com.cn" if self.region.startswith("cn-") else "amazonaws.com"
+        origin = self.endpoint_url or f"https://bedrock-runtime.{self.region}.{suffix}"
+        headers = dict(self.static_headers)
+        headers.setdefault("accept", "application/json")
+        for name, value in (
+            ("x-amzn-bedrock-guardrailidentifier", self.guardrail_identifier),
+            ("x-amzn-bedrock-guardrailversion", self.guardrail_version),
+            ("x-amzn-bedrock-trace", self.trace),
+            ("x-amzn-bedrock-performanceconfig-latency", self.performance_latency),
+            ("x-amzn-bedrock-service-tier", self.service_tier),
+        ):
+            if value is not None:
+                if name in headers and headers[name] != value:
+                    raise ValueError(f"conflicting Bedrock header declaration: {name}")
+                headers[name] = value
+        return Custom(
+            origin,
+            paths={"generative": "/model/{resource}/invoke"},
+            static_headers=headers,
+            profile_aliases=self.profile_aliases,
+        )
+
+    @staticmethod
+    def _qualify(spec: EndpointSpec) -> None:
+        if spec.op.streaming:
+            raise UnsupportedFeatureError("Bedrock streaming is not qualified yet")
+        if (spec.dialect.provider, spec.dialect.interface, spec.op.kind) != (
+            "anthropic",
+            "messages",
+            "generative",
+        ):
+            raise UnsupportedFeatureError("only Anthropic Messages InvokeModel is qualified")
+        if spec.traits.host_body_versions.get("bedrock") is None:
+            raise UnsupportedFeatureError("dialect has no explicit Bedrock version declaration")
+
+    def endpoint(self, spec: EndpointSpec) -> str:
+        """Place the unchanged resource in one encoded InvokeModel path segment."""
+        self._qualify(spec)
+        return self._target().endpoint(spec)
+
+    def headers(self, spec: EndpointSpec) -> dict[str, str]:
+        """Use trait-declared relocations and explicit non-secret host headers."""
+        self._qualify(spec)
+        result = self._target().headers(spec)
+        relocated = {key.lower() for key in spec.traits.version_headers}
+        relocated.update(
+            rule.header for rule in spec.traits.host_feature_body_mappings.get("bedrock", ())
+        )
+        return {key: value for key, value in result.items() if key.lower() not in relocated}
+
+    def envelope(self, spec: EndpointSpec) -> EnvelopeTransform:
+        """Relocate provider-bound resource/version fields without copying codecs."""
+        self._qualify(spec)
+        config = self.guardrail_config
+        if self.guardrail_identifier is not None and config is None:
+            config = dict[str, Any]()
+        return _InvokeEnvelope(spec, self.beta, config)
+
+    def profile_key(self, resource: str) -> str:
+        """Use explicit aliases only; a cloud model identifier is not qualification."""
+        return self._target().profile_key(resource)
+
+    def error_mapper(self, spec: EndpointSpec) -> HostErrorMapper:
+        """Select public native error adaptation for this qualified operation."""
+        self._qualify(spec)
+        return error_mapping()
+
+    def response_adapter(self, spec: EndpointSpec) -> HostResponseAdapter:
+        """Select declared unary metadata and guardrail effects."""
+        self._qualify(spec)
+        return response_mapping()

ocai_bedrock-0.1.1/src/ocai/bedrock/outcomes.py

@@ -0,0 +1,199 @@
+"""Bedrock-native outcome mapping behind provider-neutral host contracts."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ocai.convert import DeclaredDisposition
+from ocai.convert.host_effects import HostEffectContract
+from ocai.core import AuthError
+from ocai.core import ContentFilterError
+from ocai.core import Disposition
+from ocai.core import FieldLoss
+from ocai.core import OcaiError
+from ocai.core import RateLimitError
+from ocai.core import SemanticShift
+from ocai.core import TransientError
+from ocai.core.ir import is_json_array
+from ocai.core.ir import is_json_object
+from ocai.wire.http import HttpResponse
+from ocai.wire.outcomes import HostAdaptation
+from ocai.wire.outcomes import HostErrorMapper
+from ocai.wire.outcomes import HostResponseAdapter
+
+
+def _native_error(error: OcaiError, options: dict[str, Any]) -> OcaiError | None:
+    headers = {key.lower(): value for key, value in (error.response_headers or {}).items()}
+    raw = error.raw or {}
+    native = headers.get("x-amzn-errortype") or raw.get("__type") or raw.get("code")
+    if not isinstance(native, str) or not native:
+        return None
+    name = native.split(":", 1)[0].rsplit("#", 1)[-1]
+    error_type: type[OcaiError] | None = None
+    if name in {"ThrottlingException", "ModelNotReadyException", "ServiceQuotaExceededException"}:
+        error_type = RateLimitError
+    elif name in {
+        "ServiceUnavailableException",
+        "InternalServerException",
+        "InternalFailure",
+        "ModelTimeoutException",
+        "ModelStreamErrorException",
+        "ModelErrorException",
+    }:
+        error_type = TransientError
+    elif name in {
+        "AccessDeniedException",
+        "ExpiredTokenException",
+        "UnrecognizedClientException",
+        "NotAuthorized",
+        "IncompleteSignature",
+        "InvalidSignatureException",
+    }:
+        error_type = AuthError
+    if error_type is None:
+        error.code = native
+        return error
+    return error_type("Bedrock request failed", code=native)
+
+
+def error_mapping() -> HostErrorMapper:
+    """Build a detached native-code classifier; no status-only provider guessing."""
+    return HostErrorMapper("bedrock.invoke-errors@1", _native_error)
+
+
+def _assessment_actions(assessment: object) -> set[str]:
+    actions: set[str] = set()
+    if not is_json_object(assessment):
+        return actions
+    lanes = {
+        "topicPolicy": ("topics",),
+        "contentPolicy": ("filters",),
+        "wordPolicy": ("customWords", "managedWordLists"),
+        "sensitiveInformationPolicy": ("piiEntities", "regexes"),
+    }
+    for policy, names in lanes.items():
+        record = assessment.get(policy)
+        if not is_json_object(record):
+            continue
+        for name in names:
+            values = record.get(name)
+            if is_json_array(values):
+                actions.update(
+                    value["action"]
+                    for value in values
+                    if is_json_object(value) and isinstance(value.get("action"), str)
+                )
+    return actions
+
+
+def _actions(trace: object) -> tuple[set[str], set[str]]:
+    """Read documented assessment lanes only; modelOutput is never classified."""
+    if not is_json_object(trace) or not is_json_object(guardrail := trace.get("guardrail")):
+        return set(), set()
+    input_actions: set[str] = set()
+    input_root = guardrail.get("input")
+    if is_json_object(input_root):
+        for assessment in input_root.values():
+            input_actions.update(_assessment_actions(assessment))
+    output_actions: set[str] = set()
+    outputs = guardrail.get("outputs")
+    for root in outputs if is_json_array(outputs) else []:
+        if is_json_object(root):
+            for assessment in root.values():
+                output_actions.update(_assessment_actions(assessment))
+    return input_actions, output_actions
+
+
+def _response(
+    response: HttpResponse, payload: dict[str, Any], options: dict[str, Any]
+) -> HostAdaptation:
+    metadata: dict[str, Any] = {"body": {}, "headers": {}}
+    losses: list[FieldLoss] = []
+    for key in tuple(payload):
+        if key.startswith("amazon-bedrock-"):
+            metadata["body"][key] = payload.pop(key)
+            losses.append(
+                FieldLoss(
+                    f"body[{key}]", Disposition.RENAMED, note="Preserved in host evidence metadata"
+                )
+            )
+    for key, value in response.headers.items():
+        if key.lower() in {
+            "x-amzn-bedrock-service-tier",
+            "x-amzn-bedrock-performanceconfig-latency",
+        }:
+            metadata["headers"][key.lower()] = value
+            losses.append(
+                FieldLoss(
+                    f"headers[{key.lower()}]",
+                    Disposition.RENAMED,
+                    note="Preserved in host evidence metadata",
+                )
+            )
+    action = metadata["body"].get("amazon-bedrock-guardrailAction")
+    trace = metadata["body"].get("amazon-bedrock-trace")
+    shifts: list[SemanticShift] = []
+    error: OcaiError | None = None
+    if action == "INTERVENED":
+        input_actions, output_actions = _actions(trace)
+        if "BLOCKED" in input_actions | output_actions:
+            shifts.append(
+                SemanticShift(
+                    "bedrock.guardrail_blocked",
+                    "response",
+                    "An explicit guardrail assessment blocked the invocation",
+                )
+            )
+            error = ContentFilterError(
+                "Bedrock guardrail blocked the invocation", code="guardrail_intervened"
+            )
+        elif "ANONYMIZED" in output_actions:
+            shifts.append(
+                SemanticShift(
+                    "bedrock.masked_output",
+                    "response",
+                    "An explicit guardrail assessment anonymized output",
+                )
+            )
+        else:
+            shifts.append(
+                SemanticShift(
+                    "bedrock.guardrail_intervened",
+                    "response",
+                    "Intervention is known; its exact effect is unqualified",
+                )
+            )
+    elif action is not None and action != "NONE":
+        shifts.append(
+            SemanticShift(
+                "bedrock.guardrail_intervened",
+                "response",
+                "Unknown guardrail action preserved without interpreting it",
+            )
+        )
+    return HostAdaptation(payload, metadata, tuple(losses), tuple(shifts), error)
+
+
+def response_mapping() -> HostResponseAdapter:
+    """Declare unary host metadata and effects without changing Anthropic edges."""
+    contract = HostEffectContract(
+        census={
+            "body[]": DeclaredDisposition(
+                Disposition.RENAMED,
+                "Only amazon-bedrock-* body members move into HostEvidence.metadata",
+            ),
+            "headers[]": DeclaredDisposition(
+                Disposition.RENAMED,
+                "Selected service-tier/performance headers copy into HostEvidence.metadata",
+            ),
+        },
+        semantic_shifts=tuple(
+            SemanticShift(kind, "response")
+            for kind in (
+                "bedrock.guardrail_blocked",
+                "bedrock.masked_output",
+                "bedrock.guardrail_intervened",
+            )
+        ),
+    )
+    return HostResponseAdapter("bedrock", "bedrock.invoke-response@1", _response, contract)