Implementation Guide

    Returning the Same Block and Redaction Response Across Anthropic, Bedrock, and Vertex AI

    Enforce policy at one point in the execution path, then return a single provider-neutral response contract to every application. The contract carries a status (allowed, redacted, or blocked), a policy decision, a reason code, redaction indicators, and a correlation identifier. Provider-specific response shapes, errors, and stream events are translated to that contract at the enforcement point, so application code never branches on provider.

    Where policy is enforced for requests and responses

    1. 1

      Request stage

      Evaluate the prompt and context. Outcomes: allow, redact, or block before any provider call.

    2. 2

      Response stage

      Evaluate model output and proposed tool calls. Outcomes: allow, redact, or block before delivery.

    3. 3

      Adapter layer

      Per-provider translation of requests, responses, errors, and stream events.

    4. 4

      Native controls

      Provider-side content controls, where enabled, are inputs to the decision and are recorded, not relied on as the only control.

    Test that applications receive identical outcomes

    • Request blocked by policy: identical status, decision stage, and reason code on all three providers, with no provider call made.
    • Response blocked by policy: identical contract, with model output absent from the application payload.
    • Response redacted: identical redaction indicators and the same replaced content for the same input.
    • Stream terminated mid-response: one terminal event shape, with completion marked incomplete.
    • Provider failure: a distinct provider_error status that is never confused with a policy block.
    • Native control fires first: the contract and evidence still record the outcome in the same shape.

    Why provider-specific handling does not scale

    A team that calls Claude through Anthropic's API, Amazon Bedrock, and Google Vertex AI is calling three services that each define their own request format, response structure, error semantics, stop-reason conventions, and streaming event format. They may also apply their own native content controls. When a request or response is blocked or modified, each provider reports it in its own way.

    Without a shared enforcement point, every application absorbs that variation. One team treats a refusal as an exception, another reads it from a stop field, and a third passes partial text to the user. The result is inconsistent user-facing behavior, client code that breaks when a provider changes a format, and uneven evidence of what policy actually decided.

    This pattern is common in multi-cloud deployments. A US federal platform, for example, has been documented sending prompts from one backend to Vertex AI, Azure AI, and Bedrock and returning responses over the same channel. A single intermediary in front of several model endpoints is an established shape. The open question is what that intermediary returns when policy intervenes. Treat that as a response normalization problem with one answer.

    Define the provider-neutral contract

    The contract below is a proposed design, not a published standard. Its purpose is to let an application decide what to show a user using only these fields.

    Two design choices matter most. First, return policy outcomes in the same envelope as successful responses, with an explicit status field. A blocked request is a defined outcome, not a transport failure. Second, keep provider failures separate. Timeouts, rate limits, and upstream errors should surface as a distinct status so clients do not confuse a policy block with an outage and retry it.

    Version the contract. Adding a field should not break existing clients, and the provider-to-contract mapping should be versioned alongside it, keyed to the provider API versions you call.

    • status: One of allowed, redacted, blocked, or provider_error. Clients branch on this field only.
    • decision: The policy outcome and the stage where it applied: request or response.
    • reason_code: A stable, provider-independent code for why policy intervened, safe to map to user messages.
    • redactions: Whether content was modified, the count, and the categories affected, without the redacted values.
    • completion: Whether the output is complete or was terminated early, which matters for streams.
    • correlation_id: An identifier that ties the application response to the evidence record and the provider call.

    Streaming changes what redaction and blocking can do

    Non-streaming responses are simple to handle: the full output is available, policy evaluates it, and the contract is returned. Streaming is harder because output reaches the application incrementally, and a decision made late may apply to text already delivered.

    There are two workable approaches. The first buffers output in segments and evaluates each segment before release. This lets the enforcement point redact or block before the application sees the content, at the cost of added latency. The second releases output as it arrives and terminates the stream if a violation is found. This preserves latency but means earlier text has already been delivered. Choose per use case based on the data involved. Where leaked content is unacceptable, buffer.

    The contract should represent both cases explicitly. A stream ended by policy finishes with a terminal event carrying status blocked, a reason code, and a completion value showing the output is incomplete. A stream with redactions carries redaction indicators in its final event, and the redacted segments are replaced in the delivered text. Applications then handle one terminal event shape regardless of how each provider signals the end of a stream. Parse each provider's stream format in its adapter, and never expose it to clients.

    Evidence per decision and how native controls fit

    Each decision should produce an evidence record with the same fields regardless of provider. At minimum: the correlation identifier, timestamp, provider and model called, the policy and policy version evaluated, the stage, the outcome (allow, redact, or block), the reason code, and redaction categories and counts. For a stream, record where it was terminated. Store references or hashes rather than raw sensitive content unless your retention rules require otherwise. When allow, redact, and block decisions all produce records, an auditor can see the same outcome shown the same way across all three providers.

    Native provider content controls complement execution-path enforcement but should not replace it, because each reports in its own format and applies its own rules. Record the deciding control on every decision, whether policy at the enforcement point or a native control, so evidence does not blur which one acted. Trussed enforces policy in the execution path across models, with allow, redact, and block outcomes, and generates audit-ready evidence from those enforcement decisions.

    Governance obligations may also bear on this design. A GSA acquisition regulation document dated June 17, 2026 includes an LLM contractor clause expecting commercially available means for human oversight, intervention, and traceability, to the extent commercially available and technically feasible. It also expects notice to the Contracting Officer within 7 calendar days of a change that decreases safety guardrails or behavioral constraints. It applies only where the clause applies, and its status could change as of November 2026. Where it does apply, recording policy changes and native control changes in the same evidence trail supports that traceability.

    One contract, three providers

    Application

    Handles one schema for allow, redact, and block.

    Enforcement point

    Applies policy to requests and responses in the execution path.

    Provider adapters

    Translate Anthropic, Bedrock, and Vertex AI formats to the contract.

    Evidence record

    One decision record per interaction, identical in shape across providers.

    Enforce one policy outcome across every provider

    See how enforcement in the execution path applies allow, redact, and block decisions and produces audit-ready evidence for each one.

    Request a Demo
    Next step

    How does your AI governance program compare?

    See where your program has gaps in less than 2 minutes.