@strands-agents/sdk 0.4.0 → 0.6.0

package/dist/src/models/__tests__/bedrock.test.js

@@ -5,6 +5,7 @@ import { BedrockModel } from '../bedrock.js';
 import { ContextWindowOverflowError, ModelThrottledError } from '../../errors.js';
 import { Message, ReasoningBlock, ToolUseBlock, ToolResultBlock, JsonBlock } from '../../types/messages.js';
 import { TextBlock, GuardContentBlock, CachePointBlock } from '../../types/messages.js';
+import { CitationsBlock } from '../../types/citations.js';
 import { collectIterator } from '../../__fixtures__/model-test-helpers.js';
 /**
  * Helper function to mock BedrockRuntimeClient implementation with customizable config.
@@ -687,6 +688,77 @@ describe('BedrockModel', () => {
                 metrics: { latencyMs: 110 },
             });
         });
+        it('yields and validates citationsContent events correctly', async () => {
+            // Bedrock wire format uses object-key discrimination
+            const bedrockCitationsData = {
+                citations: [
+                    {
+                        location: { documentChar: { documentIndex: 0, start: 10, end: 50 } },
+                        sourceContent: [{ text: 'source text' }],
+                        source: 'doc-0',
+                        title: 'Test Doc',
+                    },
+                ],
+                content: [{ text: 'generated text' }],
+            };
+            const mockSend = vi.fn(async () => {
+                if (stream) {
+                    return {
+                        stream: (async function* () {
+                            yield { messageStart: { role: 'assistant' } };
+                            yield { contentBlockStart: {} };
+                            yield {
+                                contentBlockDelta: {
+                                    delta: { citationsContent: bedrockCitationsData },
+                                },
+                            };
+                            yield { contentBlockStop: {} };
+                            yield { messageStop: { stopReason: 'end_turn' } };
+                            yield {
+                                metadata: { usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 }, metrics: { latencyMs: 100 } },
+                            };
+                        })(),
+                    };
+                }
+                else {
+                    return {
+                        output: {
+                            message: {
+                                role: 'assistant',
+                                content: [{ citationsContent: bedrockCitationsData }],
+                            },
+                        },
+                        stopReason: 'end_turn',
+                        usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                        metrics: { latencyMs: 100 },
+                    };
+                }
+            });
+            mockBedrockClientImplementation({ send: mockSend });
+            const provider = new BedrockModel({ stream });
+            const messages = [new Message({ role: 'user', content: [new TextBlock('Cite this.')] })];
+            const events = await collectIterator(provider.stream(messages));
+            // SDK events should use type-field discrimination
+            expect(events).toContainEqual({ role: 'assistant', type: 'modelMessageStartEvent' });
+            expect(events).toContainEqual({ type: 'modelContentBlockStartEvent' });
+            expect(events).toContainEqual({
+                type: 'modelContentBlockDeltaEvent',
+                delta: {
+                    type: 'citationsDelta',
+                    citations: [
+                        {
+                            location: { type: 'documentChar', documentIndex: 0, start: 10, end: 50 },
+                            sourceContent: [{ text: 'source text' }],
+                            source: 'doc-0',
+                            title: 'Test Doc',
+                        },
+                    ],
+                    content: [{ text: 'generated text' }],
+                },
+            });
+            expect(events).toContainEqual({ type: 'modelContentBlockStopEvent' });
+            expect(events).toContainEqual({ stopReason: 'endTurn', type: 'modelMessageStopEvent' });
+        });
         describe('error handling', async () => {
             it.each([
                 {
@@ -1308,6 +1380,114 @@ describe('BedrockModel', () => {
             });
         });
     });
+    describe('citations content block formatting', () => {
+        const mockConverseStreamCommand = vi.mocked(ConverseStreamCommand);
+        it('maps SDK CitationLocation types to Bedrock object-key format through formatting pipeline', async () => {
+            const provider = new BedrockModel();
+            // SDK format uses type-field discrimination
+            const sdkCitations = [
+                {
+                    location: { type: 'documentChar', documentIndex: 0, start: 150, end: 300 },
+                    source: 'doc-0',
+                    sourceContent: [{ text: 'char source' }],
+                    title: 'Text Document',
+                },
+                {
+                    location: { type: 'documentPage', documentIndex: 0, start: 2, end: 3 },
+                    source: 'doc-0',
+                    sourceContent: [{ text: 'page source' }],
+                    title: 'PDF Document',
+                },
+                {
+                    location: { type: 'documentChunk', documentIndex: 1, start: 5, end: 8 },
+                    source: 'doc-1',
+                    sourceContent: [{ text: 'chunk source' }],
+                    title: 'Chunked Document',
+                },
+                {
+                    location: { type: 'searchResult', searchResultIndex: 0, start: 25, end: 150 },
+                    source: 'search-0',
+                    sourceContent: [{ text: 'search source' }],
+                    title: 'Search Result',
+                },
+                {
+                    location: { type: 'web', url: 'https://example.com/doc', domain: 'example.com' },
+                    source: 'web-0',
+                    sourceContent: [{ text: 'web source' }],
+                    title: 'Web Page',
+                },
+            ];
+            const messages = [
+                new Message({
+                    role: 'assistant',
+                    content: [
+                        new CitationsBlock({
+                            citations: sdkCitations,
+                            content: [{ text: 'generated text with all citation types' }],
+                        }),
+                    ],
+                }),
+                new Message({
+                    role: 'user',
+                    content: [new TextBlock('Follow up')],
+                }),
+            ];
+            collectIterator(provider.stream(messages));
+            // Bedrock wire format uses object-key discrimination
+            expect(mockConverseStreamCommand).toHaveBeenLastCalledWith(expect.objectContaining({
+                messages: [
+                    {
+                        role: 'assistant',
+                        content: [
+                            {
+                                citationsContent: {
+                                    citations: [
+                                        {
+                                            location: { documentChar: { documentIndex: 0, start: 150, end: 300 } },
+                                            source: 'doc-0',
+                                            sourceContent: [{ text: 'char source' }],
+                                            title: 'Text Document',
+                                        },
+                                        {
+                                            location: { documentPage: { documentIndex: 0, start: 2, end: 3 } },
+                                            source: 'doc-0',
+                                            sourceContent: [{ text: 'page source' }],
+                                            title: 'PDF Document',
+                                        },
+                                        {
+                                            location: { documentChunk: { documentIndex: 1, start: 5, end: 8 } },
+                                            source: 'doc-1',
+                                            sourceContent: [{ text: 'chunk source' }],
+                                            title: 'Chunked Document',
+                                        },
+                                        {
+                                            location: {
+                                                searchResultLocation: { searchResultIndex: 0, start: 25, end: 150 },
+                                            },
+                                            source: 'search-0',
+                                            sourceContent: [{ text: 'search source' }],
+                                            title: 'Search Result',
+                                        },
+                                        {
+                                            location: { web: { url: 'https://example.com/doc', domain: 'example.com' } },
+                                            source: 'web-0',
+                                            sourceContent: [{ text: 'web source' }],
+                                            title: 'Web Page',
+                                        },
+                                    ],
+                                    content: [{ text: 'generated text with all citation types' }],
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        content: [{ text: 'Follow up' }],
+                    },
+                ],
+            }));
+        });
+    });
     describe('includeToolResultStatus configuration', async () => {
         const mockConverseStreamCommand = vi.mocked(ConverseStreamCommand);
         describe('when includeToolResultStatus is true', () => {
@@ -1492,5 +1672,513 @@ describe('BedrockModel', () => {
             await expect(provider['_client'].config.region()).rejects.toThrow('Network error');
         });
     });
+    describe('guardrail configuration', () => {
+        const mockConverseStreamCommand = vi.mocked(ConverseStreamCommand);
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        describe('constructor', () => {
+            it('accepts guardrailConfig in options', () => {
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                    },
+                });
+                expect(provider.getConfig().guardrailConfig).toStrictEqual({
+                    guardrailIdentifier: 'my-guardrail-id',
+                    guardrailVersion: '1',
+                });
+            });
+            it('accepts guardrailConfig with all options', () => {
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                        trace: 'enabled_full',
+                        streamProcessingMode: 'sync',
+                        redaction: {
+                            input: true,
+                            inputMessage: '[Custom input redacted.]',
+                            output: true,
+                            outputMessage: '[Custom output redacted.]',
+                        },
+                    },
+                });
+                expect(provider.getConfig().guardrailConfig).toStrictEqual({
+                    guardrailIdentifier: 'my-guardrail-id',
+                    guardrailVersion: '1',
+                    trace: 'enabled_full',
+                    streamProcessingMode: 'sync',
+                    redaction: {
+                        input: true,
+                        inputMessage: '[Custom input redacted.]',
+                        output: true,
+                        outputMessage: '[Custom output redacted.]',
+                    },
+                });
+            });
+        });
+        describe('request formatting', () => {
+            it('includes guardrailConfig in request with default trace', async () => {
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                    },
+                });
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                collectIterator(provider.stream(messages));
+                expect(mockConverseStreamCommand).toHaveBeenLastCalledWith(expect.objectContaining({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                        trace: 'enabled',
+                    },
+                }));
+            });
+            it('includes guardrailConfig in request with custom trace', async () => {
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                        trace: 'disabled',
+                    },
+                });
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                collectIterator(provider.stream(messages));
+                expect(mockConverseStreamCommand).toHaveBeenLastCalledWith(expect.objectContaining({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                        trace: 'disabled',
+                    },
+                }));
+            });
+            it('includes streamProcessingMode when specified', async () => {
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                        streamProcessingMode: 'sync',
+                    },
+                });
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                collectIterator(provider.stream(messages));
+                expect(mockConverseStreamCommand).toHaveBeenLastCalledWith(expect.objectContaining({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                        trace: 'enabled',
+                        streamProcessingMode: 'sync',
+                    },
+                }));
+            });
+            it('does not include guardrailConfig when not configured', async () => {
+                const provider = new BedrockModel();
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                collectIterator(provider.stream(messages));
+                expect(mockConverseStreamCommand).toHaveBeenLastCalledWith(expect.not.objectContaining({
+                    guardrailConfig: expect.anything(),
+                }));
+            });
+        });
+        describe('blocked guardrail detection', () => {
+            it('detects blocked guardrail in inputAssessment', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { contentBlockStart: {} };
+                    yield { contentBlockDelta: { delta: { text: 'Hello' } } };
+                    yield { contentBlockStop: {} };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: {
+                                        '1234': {
+                                            topicPolicy: {
+                                                topics: [{ name: 'Harmful', action: 'BLOCKED', detected: true }],
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                    },
+                });
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                const events = await collectIterator(provider.stream(messages));
+                const redactEvent = events.find((e) => e.type === 'modelRedactionEvent');
+                expect(redactEvent).toBeDefined();
+                expect(redactEvent).toStrictEqual({
+                    type: 'modelRedactionEvent',
+                    inputRedaction: { replaceContent: '[User input redacted.]' },
+                });
+            });
+            it('detects blocked guardrail in outputAssessments', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { contentBlockStart: {} };
+                    yield { contentBlockDelta: { delta: { text: 'Hello' } } };
+                    yield { contentBlockStop: {} };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    outputAssessments: {
+                                        '1234': {
+                                            contentPolicy: {
+                                                filters: [{ type: 'VIOLENCE', action: 'BLOCKED', detected: true }],
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                    },
+                });
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                const events = await collectIterator(provider.stream(messages));
+                const redactEvent = events.find((e) => e.type === 'modelRedactionEvent');
+                expect(redactEvent).toBeDefined();
+            });
+            it('does not emit redaction events when guardrail not blocked', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { contentBlockStart: {} };
+                    yield { contentBlockDelta: { delta: { text: 'Hello' } } };
+                    yield { contentBlockStop: {} };
+                    yield { messageStop: { stopReason: 'end_turn' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: {
+                                        '1234': {
+                                            topicPolicy: {
+                                                topics: [{ name: 'Safe', action: 'NONE', detected: false }],
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'my-guardrail-id',
+                        guardrailVersion: '1',
+                    },
+                });
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                const events = await collectIterator(provider.stream(messages));
+                const redactEvent = events.find((e) => e.type === 'modelRedactionEvent');
+                expect(redactEvent).toBeUndefined();
+            });
+            it('does not emit redaction events without guardrailConfig', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { contentBlockStart: {} };
+                    yield { contentBlockDelta: { delta: { text: 'Hello' } } };
+                    yield { contentBlockStop: {} };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: {
+                                        '1234': {
+                                            topicPolicy: {
+                                                topics: [{ name: 'Harmful', action: 'BLOCKED', detected: true }],
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel();
+                const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
+                const events = await collectIterator(provider.stream(messages));
+                const redactEvent = events.find((e) => e.type === 'modelRedactionEvent');
+                expect(redactEvent).toBeUndefined();
+            });
+        });
+        describe('redaction event generation', () => {
+            it('emits input redaction with default message', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: { '1': { topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } } },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    inputRedaction: { replaceContent: '[User input redacted.]' },
+                });
+            });
+            it('emits input redaction with custom message', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: { '1': { topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } } },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                        redaction: {
+                            inputMessage: '[Custom input message]',
+                        },
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    inputRedaction: { replaceContent: '[Custom input message]' },
+                });
+            });
+            it('does not emit input redaction when redactInput is false', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: { '1': { topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } } },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                        redaction: {
+                            input: false,
+                        },
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                const inputRedactEvent = events.find((e) => e.type === 'modelRedactionEvent' && 'inputRedaction' in e);
+                expect(inputRedactEvent).toBeUndefined();
+            });
+            it('emits output redaction when redactOutput is true', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: { '1': { topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } } },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                        redaction: {
+                            output: true,
+                        },
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    outputRedaction: { replaceContent: '[Assistant output redacted.]' },
+                });
+            });
+            it('emits output redaction with custom message', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: { '1': { topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } } },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                        redaction: {
+                            output: true,
+                            outputMessage: '[Custom output message]',
+                        },
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    outputRedaction: { replaceContent: '[Custom output message]' },
+                });
+            });
+            it('emits both input and output redaction when both are enabled', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    inputAssessment: { '1': { topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } } },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                        redaction: {
+                            input: true,
+                            output: true,
+                        },
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    inputRedaction: { replaceContent: '[User input redacted.]' },
+                });
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    outputRedaction: { replaceContent: '[Assistant output redacted.]' },
+                });
+            });
+            it('includes redactedContent from modelOutput when available', async () => {
+                setupMockSend(async function* () {
+                    yield { messageStart: { role: 'assistant' } };
+                    yield { contentBlockStart: {} };
+                    yield { contentBlockDelta: { delta: { text: 'This content was blocked' } } };
+                    yield { contentBlockStop: {} };
+                    yield { messageStop: { stopReason: 'guardrail_intervened' } };
+                    yield {
+                        metadata: {
+                            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                            trace: {
+                                guardrail: {
+                                    modelOutput: ['This content ', 'was blocked'],
+                                    outputAssessments: {
+                                        '0': [{ topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } }],
+                                    },
+                                },
+                            },
+                        },
+                    };
+                });
+                const provider = new BedrockModel({
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                        redaction: {
+                            output: true,
+                            outputMessage: '[Blocked]',
+                        },
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    outputRedaction: {
+                        replaceContent: '[Blocked]',
+                        redactedContent: 'This content was blocked',
+                    },
+                });
+            });
+        });
+        describe('non-streaming mode', () => {
+            it('emits redaction events in non-streaming mode when guardrail blocks', async () => {
+                const mockSend = vi.fn(async () => ({
+                    output: {
+                        message: {
+                            role: 'assistant',
+                            content: [{ text: 'Hello' }],
+                        },
+                    },
+                    stopReason: 'guardrail_intervened',
+                    usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+                    trace: {
+                        guardrail: {
+                            inputAssessment: { '1': { topicPolicy: { topics: [{ action: 'BLOCKED', detected: true }] } } },
+                        },
+                    },
+                }));
+                mockBedrockClientImplementation({ send: mockSend });
+                const provider = new BedrockModel({
+                    stream: false,
+                    guardrailConfig: {
+                        guardrailIdentifier: 'id',
+                        guardrailVersion: '1',
+                    },
+                });
+                const events = await collectIterator(provider.stream([new Message({ role: 'user', content: [new TextBlock('Hello')] })]));
+                expect(events).toContainEqual({
+                    type: 'modelRedactionEvent',
+                    inputRedaction: { replaceContent: '[User input redacted.]' },
+                });
+            });
+        });
+    });
 });
 //# sourceMappingURL=bedrock.test.js.map