Attestation

@bedrockgovernance/attest is the SDK that captures a generation (the event of a model producing a piece of advice) and records it as an immutable ledger entry. Where a review job attests what document was produced and reviewed, an attestation captures exactly what the model saw and returned.

What a generation captures

A single attest() call records the complete generation bundle. Only model, systemPrompt, messages, and output are required. Everything else is optional, included when your pipeline has it.

{
  "clientReference": "CLI-41269355",
  "correlationId": "af3c1e90-6b2d-4e7a-9c11-0d2b8e5f4a12",
  "adviser": { "name": "Jane Smith", "fcaRef": "JXS01234" },
  "model": {
    "provider": "anthropic",
    "name": "claude-opus-4-8",
    "parameters": { "temperature": 0.2, "maxTokens": 4096 }
  },
  "systemPrompt": "You are a suitability report assistant. Never recommend...",
  "messages": [
    { "role": "user", "content": "Draft a suitability report for a balanced investor..." }
  ],
  "promptTemplate": { "id": "suitability-v3", "version": "3.2.1", "hash": "sha256:9f2c..." },
  "retrievedContext": [
    { "source": "intelliflo:factfind", "reference": "20655934", "hash": "sha256:1a4b..." }
  ],
  "guardrails": [
    { "rule": "MAX_EQUITY_ALLOCATION", "triggered": false },
    { "rule": "VULNERABLE_CLIENT_CHECK", "triggered": true, "action": "flagged_for_review" }
  ],
  "output": {
    "content": "## Suitability Report\n\nBased on your balanced risk profile...",
    "finishReason": "stop"
  },
  "usage": { "inputTokens": 3120, "outputTokens": 1840 }
}

Fields

Two ways to call it

Attest explicitly when you want to hand Bedrock the bundle yourself:

import { Bedrock } from '@bedrockgovernance/attest';

const bedrock = new Bedrock({ apiKey: process.env.BEDROCK_API_KEY });

// Mint one correlationId when the drafting session starts, reuse it
// for every attest() call and again at submission.
const correlationId = crypto.randomUUID();

const { generationId } = await bedrock.attest({
  clientReference,
  correlationId,
  adviser: { name: 'Jane Smith', fcaRef: 'JXS01234' },
  model: { provider: 'anthropic', name: 'claude-opus-4-8' },
  systemPrompt,
  messages,
  retrievedContext,
  output: { content: draft, finishReason: 'stop' },
});

Or wrap your model with the AI SDK middleware so every call is notarised automatically, with no change to your generation code:

import { wrapLanguageModel } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { attestMiddleware } from '@bedrockgovernance/attest/ai-sdk';

const model = wrapLanguageModel({
  model: anthropic('claude-opus-4-8'),
  middleware: attestMiddleware({ bedrock, clientReference, correlationId, adviser }),
});

// Every generateText / streamText call now writes an attestation.

The middleware captures the request parameters and the result and posts the attestation in the background, so it never adds latency to the response. For stacks that do not use the AI SDK, the explicit attest() call works from any runtime.

How it links into the chain

An attestation is written as a GENERATION_RECORDED ledger record through the same write path as every other event: canonicalised, hashed, chained to the previous record, signed with the firm's key, and mirrored to object-locked storage. It becomes a first-class link in the firm's ledger before the document is submitted.

1. The generation tool calls attest(), tagging the call with a correlationId it minted for this piece of advice. Bedrock records a GENERATION_RECORDED event and returns a generationId.
2. The advice document is saved to the CRM or advice platform.
3. When the document is submitted for review, the submission carries the same correlationId. That binds the whole generation set to the review job and seals it. The submitted document's hash is compared to the generations' outputHash values; a match to the final generation confirms the model's output was used verbatim, a mismatch is recorded as a human edit after generation.
4. The completed chain reads GENERATION_RECORDED (one or more) then DOCUMENT_SUBMITTED then the review outcome.

Linking multiple generations to one document

A single piece of advice is rarely one model call. Each generation is a separate attest() call and a separate GENERATION_RECORDED record, and all of them need to resolve to the one document that is eventually submitted.

• correlationId is the join key. Your tool mints one id when a drafting session begins and tags every attest() call with it, so the firm's ledger holds a set of generations rather than isolated records.
• supersedes orders the set, optionally. Each revision names the generationId it replaces, so the records form an explicit draft, revision, final lineage. It is enrichment, not the join: leave it out and the ledger sequence still gives chronological order.

The submission is what marks the set complete. The result is that a regulator can see not just the prompt behind the final wording, but every intermediate prompt and output that shaped it, each independently hashed into the chain.

Try it

npm install @bedrockgovernance/attest

See also

• Build a generation integration
• AI context
• The Ledger
• Notary
• Ledger events