@telemetry-dev/bedrock 0.1.9 → 0.1.10

package/README.md

@@ -138,8 +138,11 @@ InvokeModel captures provider-native JSON bodies verbatim. Non-JSON bodies are n
 - Instrumentation is fail-open. Normalization, span updates, and span endings are guarded so telemetry failures do not break caller code.
 - Requests are never modified. This is especially important for AWS SigV4 signing and for application-level request object reuse.
 - Streams are pull-through. The wrapper does not pre-buffer chunks and therefore preserves backpressure.
-- Streams end spans exactly once. Exhaustion records full output and finish reason; early `break`, `return()`, `close()`, abort, or stream errors record partial output.
+- Streams end spans exactly once. Exhaustion records full output and finish reason; early `break`, `return()`, `close()`, abort, or stream errors record partial output and set `telemetry.dev.capture.truncated`.
+- Stream reconstruction (output, Agent trace events, and Agent output-file metadata) retains up to 48 KiB and 1,000 items; events past the bound still pass through to the caller. The configured `maxAttributeLength` does not shrink this bound; the core applies it to the exported attribute after the mask runs.
+- A stream cut at the bound, stopped early, or failed sets `telemetry.dev.capture.truncated`. With a mask configured, its incomplete reconstructed output is omitted because the mask cannot inspect the complete value. Agent trace events and output-file metadata share the bound, but dropping them only sets the attribute; Agent text is omitted only when a text chunk was dropped or the stream stopped early or failed. A normally exhausted Agent stream that returned control keeps its complete `returnControl` output even if earlier text or metadata passed the bound; an early stop or failure still omits the output when a mask is configured.
 - `AbortSignal` passed to `send(command, { abortSignal })` is forwarded untouched. Pre-response aborts end the span with the thrown abort error. Mid-stream aborts end the span with partial output and the stream error.
+- `Rerank` input and results are bounded to 48 KiB and 1,000 items. A value over the bound sets `telemetry.dev.capture.truncated`. Without a mask, the bounded part is kept. With a mask configured, that value is omitted because the mask cannot inspect the complete value. Input is omitted before the span starts, so a custom `sampler` sees the bounded input when no mask is configured; with an older `@telemetry-dev/sdk` that cannot report whether a mask is configured, cut input is omitted as if one were.
 - Callback-style `send(command, callback)` and `send(command, options, callback)` calls are instrumented; callbacks receive the original data/error while the span is ended before callback invocation.
 
 ## Coverage gaps

package/dist/agents.mjs

@@ -1,4 +1,4 @@
-import { r as createInstrumentedSend, t as AGENT_HANDLERS } from "./internal-handlers-Byxp14OZ.mjs";
+import { r as createInstrumentedSend, t as AGENT_HANDLERS } from "./internal-handlers-PftQAPH3.mjs";
 import { BedrockAgentRuntimeClient } from "@aws-sdk/client-bedrock-agent-runtime";
 //#region src/agents.ts
 const WRAPPED = /* @__PURE__ */ new WeakSet();

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as RUNTIME_HANDLERS, r as createInstrumentedSend } from "./internal-handlers-Byxp14OZ.mjs";
+import { n as RUNTIME_HANDLERS, r as createInstrumentedSend } from "./internal-handlers-PftQAPH3.mjs";
 import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
 //#region src/index.ts
 const WRAPPED = /* @__PURE__ */ new WeakSet();

package/dist/{internal-handlers-Byxp14OZ.mjs → internal-handlers-PftQAPH3.mjs}

@@ -1,4 +1,5 @@
-import { boundedCapture, captureEnabled, startSpan } from "@telemetry-dev/sdk";
+import * as telemetrySdk from "@telemetry-dev/sdk";
+import { boundedCapture, boundedCaptureDetails, captureEnabled, startSpan } from "@telemetry-dev/sdk";
 //#region src/internal.ts
 const PROVIDER = "amazon-bedrock";
 const STREAM_FINALIZER = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((finish) => finish()) : void 0;
@@ -12,7 +13,7 @@ function createInstrumentedSend(originalSend, options, handlers) {
 		const input = commandInput(rawCommand);
 		const t0 = performance.now();
 		const spanType = safe(() => handler.spanType(input)) ?? "span";
-		const span = startSpan(safe(() => handler.spanName(input)) ?? name ?? "bedrock", {
+		const span = startRequestSpan(safe(() => handler.spanName(input)) ?? name ?? "bedrock", {
 			type: spanType,
 			...safe(() => handler.requestFields(input, options)) ?? {}
 		});
@@ -103,6 +104,33 @@ function withCacheInclusiveInput(fields) {
 		}
 	};
 }
+function capturesWithMask(span) {
+	return span.capturePolicy?.mask ?? true;
+}
+function isCut(fields) {
+	return fields?.attributes?.["telemetry.dev.capture.truncated"] === true;
+}
+function captureMaskedBeforeStart() {
+	const read = telemetrySdk.captureMasked;
+	try {
+		return typeof read === "function" ? read() : true;
+	} catch {
+		return true;
+	}
+}
+function startRequestSpan(name, options) {
+	return startSpan(name, options.input !== void 0 && isCut(options) && captureMaskedBeforeStart() ? {
+		...options,
+		input: void 0
+	} : options);
+}
+/** Ends a non-streamed span, withholding output cut to the retention bound from a mask. */
+function endSpanWithBoundedOutput(span, fields) {
+	endSpan(span, fields.output !== void 0 && isCut(fields) && capturesWithMask(span) ? {
+		...fields,
+		output: void 0
+	} : fields);
+}
 function endSpan(span, fields) {
 	try {
 		span.end(withCacheInclusiveInput(fields));
@@ -209,6 +237,46 @@ function parseJson(value) {
 		return;
 	}
 }
+const STREAM_CAPTURE_MAX_BYTES = 48 * 1024;
+const STREAM_CAPTURE_MAX_ITEMS = 1e3;
+const CAPTURE_TRUNCATED_ATTRIBUTE = "telemetry.dev.capture.truncated";
+const LEGACY_CAPTURE_POLICY = {
+	output: true,
+	mask: true,
+	maxAttributeLength: 65536
+};
+/** Tracks the fixed byte and item bound before a stream state retains a value. */
+var StreamRetention = class {
+	bytes = 0;
+	items = 0;
+	truncated = false;
+	accept(value) {
+		if (this.truncated) return false;
+		const measured = boundedCaptureDetails(value, {
+			maxBytes: STREAM_CAPTURE_MAX_BYTES - this.bytes,
+			maxItems: STREAM_CAPTURE_MAX_ITEMS - this.items
+		});
+		if (measured.truncated) {
+			this.truncated = true;
+			return false;
+		}
+		this.bytes += measured.bytes;
+		this.items += measured.items;
+		return true;
+	}
+};
+function finishStream(state, span, partial) {
+	const fields = state.finish(partial);
+	const interrupted = partial || fields.error !== void 0;
+	if (!interrupted && !state.retention.truncated) return fields;
+	fields.attributes = {
+		...fields.attributes,
+		[CAPTURE_TRUNCATED_ATTRIBUTE]: true
+	};
+	const outputTruncated = state.outputTruncated?.() ?? state.retention.truncated;
+	if ((span.capturePolicy ?? LEGACY_CAPTURE_POLICY).mask && (interrupted || outputTruncated)) delete fields.output;
+	return fields;
+}
 function wrapAsyncIterable(iterable, state, span, t0, baseFields, trackOutputChunks = true) {
 	if (!iterable || !isAsyncIterable(iterable)) {
 		endSpan(span, baseFields);
@@ -238,15 +306,15 @@ function wrapAsyncIterable(iterable, state, span, t0, baseFields, trackOutputChu
 			}
 			completed = true;
 		} catch (error) {
-			endOnce(mergeFields(state.finish(true), awsMetadataFields(metadataOf(error)), { error: asError(error) }));
+			endOnce(mergeFields(finishStream(state, span, true), awsMetadataFields(metadataOf(error)), { error: asError(error) }));
 			throw error;
 		} finally {
-			if (!ended) endOnce(state.finish(!completed));
+			if (!ended) endOnce(finishStream(state, span, !completed));
 		}
 	};
 	const wrapped = {};
 	if (isRecord(iterable)) for (const key of Reflect.ownKeys(iterable)) wrapped[key] = iterable[key];
-	const finishAbandoned = () => endOnce(safe(() => state.finish(true)));
+	const finishAbandoned = () => endOnce(safe(() => finishStream(state, span, true)));
 	wrapped[Symbol.asyncIterator] = () => {
 		const iterator = generator();
 		STREAM_FINALIZER?.register(iterator, finishAbandoned, unregisterToken);
@@ -340,12 +408,16 @@ function inlineAgentRequestFields(input) {
 	});
 }
 var AgentStreamState = class {
+	retention = new StreamRetention();
 	text = "";
+	textRejected = false;
 	usage = {};
 	traceEventCount = 0;
 	failureReason;
 	guardrailAction;
 	returnControl;
+	sawReturnControl = false;
+	returnControlRejected = false;
 	traces = [];
 	error;
 	errorFields;
@@ -365,17 +437,27 @@ var AgentStreamState = class {
 		}
 		const chunk = isRecord(raw.chunk) ? raw.chunk : void 0;
 		const bytes = chunk?.bytes;
-		if (bytes !== void 0) this.text += bytesToString(bytes) ?? "";
+		const piece = bytes === void 0 ? void 0 : bytesToString(bytes);
+		if (piece) if (this.retention.accept(piece)) this.text += piece;
+		else this.textRejected = true;
 		const citations = arrayValue((isRecord(chunk?.attribution) ? chunk.attribution : void 0)?.citations);
 		if (citations) this.citationCount += citations.length;
-		const files = isRecord(raw.files) ? arrayValue(raw.files.files) : void 0;
-		if (files) this.outputFiles.push(...files.map(sanitizeOutputFile));
+		const sanitizedFiles = (isRecord(raw.files) ? arrayValue(raw.files.files) : void 0)?.map(sanitizeOutputFile);
+		if (sanitizedFiles && this.retention.accept(sanitizedFiles)) this.outputFiles.push(...sanitizedFiles);
 		const returnControl = isRecord(raw.returnControl) ? raw.returnControl : void 0;
-		if (returnControl) this.returnControl = returnControl;
+		if (returnControl) {
+			this.sawReturnControl = true;
+			if (new StreamRetention().accept(returnControl)) this.returnControl = returnControl;
+			else {
+				this.returnControl = void 0;
+				this.returnControlRejected = true;
+				this.retention.truncated = true;
+			}
+		}
 		const traceEvent = isRecord(raw.trace) ? raw.trace : void 0;
 		if (traceEvent) {
 			this.traceEventCount += 1;
-			if (this.options.captureAgentTrace) this.traces.push(traceEvent);
+			if (this.options.captureAgentTrace && this.retention.accept(traceEvent)) this.traces.push(traceEvent);
 			collectTrace(traceEvent, (usage) => this.addUsage(usage));
 			const failure = findKey(traceEvent, "failureTrace");
 			if (isRecord(failure)) this.failureReason = stringValue(failure.failureReason) ?? this.failureReason;
@@ -383,12 +465,16 @@ var AgentStreamState = class {
 			if (isRecord(guardrail)) this.guardrailAction = stringValue(guardrail.action) ?? this.guardrailAction;
 		}
 	}
+	outputTruncated() {
+		if (this.returnControl !== void 0) return false;
+		return this.textRejected || this.returnControlRejected;
+	}
 	finish() {
 		const metadata = omitUndefined({
 			trace_event_count: this.traceEventCount || void 0,
 			failure_reason: this.failureReason,
 			guardrail_action: this.guardrailAction,
-			return_control: this.returnControl ? true : void 0,
+			return_control: this.sawReturnControl ? true : void 0,
 			citation_count: this.citationCount || void 0,
 			output_files: this.outputFiles.length > 0 ? this.outputFiles : void 0,
 			agent_trace: this.options.captureAgentTrace && this.traces.length > 0 ? this.traces : void 0
@@ -533,6 +619,7 @@ function ragResponseFields(output) {
 	});
 }
 var RagStreamState = class {
+	retention = new StreamRetention();
 	text = "";
 	citationCount = 0;
 	guardrailAction;
@@ -547,8 +634,8 @@ var RagStreamState = class {
 			this.errorFields = streamError.fields;
 			return;
 		}
-		const output = isRecord(raw.output) ? raw.output : void 0;
-		this.text += stringValue(output?.text) ?? "";
+		const text = stringValue((isRecord(raw.output) ? raw.output : void 0)?.text);
+		if (text && this.retention.accept(text)) this.text += text;
 		if (raw.citation) this.citationCount += 1;
 		const guardrail = isRecord(raw.guardrail) ? raw.guardrail : void 0;
 		this.guardrailAction = stringValue(guardrail?.action) ?? this.guardrailAction;
@@ -578,6 +665,7 @@ function flowRequestFields(input) {
 	});
 }
 var FlowStreamState = class {
+	retention = new StreamRetention();
 	outputs = [];
 	completionReason;
 	error;
@@ -592,9 +680,9 @@ var FlowStreamState = class {
 			return;
 		}
 		const output = isRecord(raw.flowOutputEvent) ? raw.flowOutputEvent : void 0;
-		if (output) this.outputs.push(output.content);
+		if (output && this.retention.accept(output.content)) this.outputs.push(output.content);
 		const inputRequest = isRecord(raw.flowMultiTurnInputRequestEvent) ? raw.flowMultiTurnInputRequestEvent : void 0;
-		if (inputRequest) this.outputs.push(inputRequest.content);
+		if (inputRequest && this.retention.accept(inputRequest.content)) this.outputs.push(inputRequest.content);
 		const completion = isRecord(raw.flowCompletionEvent) ? raw.flowCompletionEvent : void 0;
 		this.completionReason = stringValue(completion?.completionReason) ?? this.completionReason;
 	}
@@ -801,6 +889,7 @@ function s3Uri(value) {
 	return bucket && key ? `s3://${bucket}/${key}` : void 0;
 }
 var ConverseStreamState = class {
+	retention = new StreamRetention();
 	role = "assistant";
 	blocks = /* @__PURE__ */ new Map();
 	stopReason;
@@ -820,7 +909,7 @@ var ConverseStreamState = class {
 		const messageStart = isRecord(event.messageStart) ? event.messageStart : void 0;
 		if (messageStart) this.role = stringValue(messageStart.role) ?? this.role;
 		const blockStart = isRecord(event.contentBlockStart) ? event.contentBlockStart : void 0;
-		if (blockStart) {
+		if (blockStart && this.retention.accept(blockStart.start ?? {})) {
 			const index = numberValue(blockStart.contentBlockIndex) ?? this.blocks.size;
 			const start = isRecord(blockStart.start) ? blockStart.start : void 0;
 			const toolUse = isRecord(start?.toolUse) ? start?.toolUse : void 0;
@@ -847,9 +936,9 @@ var ConverseStreamState = class {
 			});
 		}
 		const deltaEvent = isRecord(event.contentBlockDelta) ? event.contentBlockDelta : void 0;
-		if (deltaEvent) {
+		const delta = isRecord(deltaEvent?.delta) ? deltaEvent.delta : {};
+		if (deltaEvent && this.retention.accept(delta)) {
 			const index = numberValue(deltaEvent.contentBlockIndex) ?? 0;
-			const delta = isRecord(deltaEvent.delta) ? deltaEvent.delta : {};
 			const block = this.blocks.get(index) ?? {
 				kind: "text",
 				text: ""
@@ -1109,6 +1198,7 @@ function headerNumber(value) {
 	return numberValue(value);
 }
 var InvokeModelStreamState = class {
+	retention = new StreamRetention();
 	chunks = [];
 	text = "";
 	usage;
@@ -1129,8 +1219,10 @@ var InvokeModelStreamState = class {
 			const raw = chunk?.bytes;
 			return (typeof raw === "string" || raw instanceof Uint8Array) && raw.length > 0;
 		}
-		this.chunks.push(parsed);
-		this.text += textFromProviderChunk(parsed);
+		if (this.retention.accept(parsed)) {
+			this.chunks.push(parsed);
+			this.text += textFromProviderChunk(parsed);
+		}
 		if (isRecord(parsed)) {
 			const delta = isRecord(parsed.delta) ? parsed.delta : void 0;
 			const message = isRecord(parsed.message) ? parsed.message : void 0;
@@ -1278,7 +1370,7 @@ const AGENT_HANDLERS = {
 		spanType: () => "span",
 		requestFields: rerankRequestFields,
 		onResult(result, span) {
-			endSpan(span, rerankResponseFields(result));
+			endSpanWithBoundedOutput(span, rerankResponseFields(result));
 			return result;
 		}
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetry-dev/bedrock",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "AWS Bedrock instrumentation for telemetry.dev: Converse, InvokeModel, and Bedrock Agents spans for AWS SDK v3 clients.",
   "keywords": [
     "aws",
@@ -49,7 +49,7 @@
     "@smithy/eventstream-codec": "^4.2.5",
     "@smithy/protocol-http": "^5.3.10",
     "@smithy/types": "^4.12.0",
-    "@telemetry-dev/sdk": "^0.1.7",
+    "@telemetry-dev/sdk": "^0.1.8",
     "@types/node": "^25.5.0",
     "@typescript/native-preview": "7.0.0-dev.20260328.1",
     "typescript": "^6.0.2",
@@ -59,7 +59,7 @@
   "peerDependencies": {
     "@aws-sdk/client-bedrock-agent-runtime": ">=3.600.0 <4",
     "@aws-sdk/client-bedrock-runtime": ">=3.600.0 <4",
-    "@telemetry-dev/sdk": "^0.1.7"
+    "@telemetry-dev/sdk": "^0.1.8"
   },
   "peerDependenciesMeta": {
     "@aws-sdk/client-bedrock-agent-runtime": {

package/src/agent-handlers.ts

@@ -12,6 +12,7 @@ import {
   omitUndefined,
   PROVIDER,
   stringValue,
+  StreamRetention,
   type BedrockInstrumentationOptions,
   type JsonRecord,
   type JsonValue,
@@ -48,12 +49,17 @@ export function inlineAgentRequestFields(input: JsonRecord): SpanFields {
 }
 
 export class AgentStreamState implements StreamState {
+  readonly retention = new StreamRetention();
   private text = "";
+  // Trace and output-file metadata share the budget but do not make the text incomplete.
+  private textRejected = false;
   private usage: NonNullable<SpanFields["usage"]> = {};
   private traceEventCount = 0;
   private failureReason: string | undefined;
   private guardrailAction: string | undefined;
   private returnControl: unknown;
+  private sawReturnControl = false;
+  private returnControlRejected = false;
   private readonly traces: unknown[] = [];
   private error: Error | undefined;
   private errorFields: SpanFields | undefined;
@@ -78,7 +84,12 @@ export class AgentStreamState implements StreamState {
     const chunk = isRecord(raw.chunk) ? raw.chunk : undefined;
     const bytes = chunk?.bytes;
 
-    if (bytes !== undefined) this.text += bytesToString(bytes) ?? "";
+    const piece = bytes === undefined ? undefined : bytesToString(bytes);
+
+    if (piece) {
+      if (this.retention.accept(piece)) this.text += piece;
+      else this.textRejected = true;
+    }
     const attribution = isRecord(chunk?.attribution) ? chunk.attribution : undefined;
     const citations = arrayValue<unknown>(attribution?.citations);
 
@@ -86,18 +97,37 @@ export class AgentStreamState implements StreamState {
 
     const files = isRecord(raw.files) ? arrayValue<JsonValue>(raw.files.files) : undefined;
 
-    if (files) this.outputFiles.push(...files.map(sanitizeOutputFile));
+    const sanitizedFiles = files?.map(sanitizeOutputFile);
+
+    if (sanitizedFiles && this.retention.accept(sanitizedFiles)) {
+      this.outputFiles.push(...sanitizedFiles);
+    }
 
     const returnControl = isRecord(raw.returnControl) ? raw.returnControl : undefined;
 
-    if (returnControl) this.returnControl = returnControl;
+    if (returnControl) {
+      this.sawReturnControl = true;
+
+      // Return control replaces the text output, so it gets its own fresh bound and survives
+      // text that already spent the shared budget; one that alone does not fit is dropped and
+      // the capture is marked incomplete.
+      if (new StreamRetention().accept(returnControl)) {
+        this.returnControl = returnControl;
+      } else {
+        this.returnControl = undefined;
+        this.returnControlRejected = true;
+        this.retention.truncated = true;
+      }
+    }
 
     const traceEvent = isRecord(raw.trace) ? raw.trace : undefined;
 
     if (traceEvent) {
       this.traceEventCount += 1;
 
-      if (this.options.captureAgentTrace) this.traces.push(traceEvent);
+      if (this.options.captureAgentTrace && this.retention.accept(traceEvent)) {
+        this.traces.push(traceEvent);
+      }
       collectTrace(traceEvent, (usage) => this.addUsage(usage));
       const failure = findKey(traceEvent, "failureTrace");
 
@@ -110,12 +140,19 @@ export class AgentStreamState implements StreamState {
     }
   }
 
+  outputTruncated(): boolean {
+    // Return control replaces the text output and is retained whole when it fits its bound.
+    if (this.returnControl !== undefined) return false;
+
+    return this.textRejected || this.returnControlRejected;
+  }
+
   finish(): SpanFields {
     const metadata = omitUndefined({
       trace_event_count: this.traceEventCount || undefined,
       failure_reason: this.failureReason,
       guardrail_action: this.guardrailAction,
-      return_control: this.returnControl ? true : undefined,
+      return_control: this.sawReturnControl ? true : undefined,
       citation_count: this.citationCount || undefined,
       output_files: this.outputFiles.length > 0 ? this.outputFiles : undefined,
       agent_trace:
@@ -303,6 +340,7 @@ export function ragResponseFields<T>(output: T): SpanFields {
 }
 
 export class RagStreamState implements StreamState {
+  readonly retention = new StreamRetention();
   private text = "";
   private citationCount = 0;
   private guardrailAction: string | undefined;
@@ -323,7 +361,9 @@ export class RagStreamState implements StreamState {
     }
 
     const output = isRecord(raw.output) ? raw.output : undefined;
-    this.text += stringValue(output?.text) ?? "";
+    const text = stringValue(output?.text);
+
+    if (text && this.retention.accept(text)) this.text += text;
 
     if (raw.citation) this.citationCount += 1;
     const guardrail = isRecord(raw.guardrail) ? raw.guardrail : undefined;
@@ -356,6 +396,7 @@ export function flowRequestFields(input: JsonRecord): SpanFields {
 }
 
 export class FlowStreamState implements StreamState {
+  readonly retention = new StreamRetention();
   private outputs: unknown[] = [];
   private completionReason: string | undefined;
   private error: Error | undefined;
@@ -376,13 +417,15 @@ export class FlowStreamState implements StreamState {
 
     const output = isRecord(raw.flowOutputEvent) ? raw.flowOutputEvent : undefined;
 
-    if (output) this.outputs.push(output.content);
+    if (output && this.retention.accept(output.content)) this.outputs.push(output.content);
 
     const inputRequest = isRecord(raw.flowMultiTurnInputRequestEvent)
       ? raw.flowMultiTurnInputRequestEvent
       : undefined;
 
-    if (inputRequest) this.outputs.push(inputRequest.content);
+    if (inputRequest && this.retention.accept(inputRequest.content)) {
+      this.outputs.push(inputRequest.content);
+    }
     const completion = isRecord(raw.flowCompletionEvent) ? raw.flowCompletionEvent : undefined;
     this.completionReason = stringValue(completion?.completionReason) ?? this.completionReason;
   }

package/src/converse.ts

@@ -11,6 +11,7 @@ import {
   parseJson,
   PROVIDER,
   stringValue,
+  StreamRetention,
   type JsonRecord,
   type JsonValue,
   type StreamState,
@@ -256,6 +257,7 @@ interface StreamBlock {
 }
 
 export class ConverseStreamState implements StreamState {
+  readonly retention = new StreamRetention();
   private role = "assistant";
   private readonly blocks = new Map<number, StreamBlock>();
   private stopReason: string | undefined;
@@ -282,7 +284,7 @@ export class ConverseStreamState implements StreamState {
 
     const blockStart = isRecord(event.contentBlockStart) ? event.contentBlockStart : undefined;
 
-    if (blockStart) {
+    if (blockStart && this.retention.accept(blockStart.start ?? {})) {
       const index = numberValue(blockStart.contentBlockIndex) ?? this.blocks.size;
       const start = isRecord(blockStart.start) ? blockStart.start : undefined;
       const toolUse = isRecord(start?.toolUse) ? start?.toolUse : undefined;
@@ -316,9 +318,10 @@ export class ConverseStreamState implements StreamState {
 
     const deltaEvent = isRecord(event.contentBlockDelta) ? event.contentBlockDelta : undefined;
 
-    if (deltaEvent) {
+    const delta = isRecord(deltaEvent?.delta) ? deltaEvent.delta : {};
+
+    if (deltaEvent && this.retention.accept(delta)) {
       const index = numberValue(deltaEvent.contentBlockIndex) ?? 0;
-      const delta = isRecord(deltaEvent.delta) ? deltaEvent.delta : {};
       const block = this.blocks.get(index) ?? { kind: "text", text: "" };
       const text = stringValue(delta.text);
 

package/src/internal-handlers.ts

@@ -32,6 +32,7 @@ import {
   stringValue,
   wrapAsyncIterable,
   endSpan,
+  endSpanWithBoundedOutput,
   type BedrockInstrumentationOptions,
 } from "./internal.ts";
 
@@ -154,7 +155,7 @@ export const AGENT_HANDLERS = {
     spanType: () => "span",
     requestFields: rerankRequestFields,
     onResult(result, span) {
-      endSpan(span, rerankResponseFields(result));
+      endSpanWithBoundedOutput(span, rerankResponseFields(result));
 
       return result;
     },

package/src/internal.ts

@@ -1,4 +1,12 @@
-import { startSpan, type SpanFields, type SpanHandle, type SpanType } from "@telemetry-dev/sdk";
+import {
+  boundedCaptureDetails,
+  startSpan,
+  type SpanFields,
+  type SpanHandle,
+  type SpanType,
+  type StartSpanOptions,
+} from "@telemetry-dev/sdk";
+import * as telemetrySdk from "@telemetry-dev/sdk";
 
 export const PROVIDER = "amazon-bedrock";
 
@@ -64,7 +72,7 @@ export function createInstrumentedSend(
     const spanType = safe(() => handler.spanType(input)) ?? "span";
     const spanName = safe(() => handler.spanName(input)) ?? name ?? "bedrock";
     const fields = safe(() => handler.requestFields(input, options)) ?? {};
-    const span = startSpan(spanName, { type: spanType, ...fields });
+    const span = startRequestSpan(spanName, { type: spanType, ...fields });
     const callbackIndex = rawRest.findIndex((arg) => arg instanceof Function);
 
     if (callbackIndex !== -1) {
@@ -162,6 +170,42 @@ function withCacheInclusiveInput(fields: SpanFields | undefined): SpanFields | u
   return { ...fields, usage: { ...usage, inputTokens, totalTokens } };
 }
 
+// A capture cut to the retention bound keeps its truncated flag, but a mask cannot be trusted to
+// redact a value it only sees part of. Cores without a capture policy are treated as masked.
+function capturesWithMask(span: SpanHandle): boolean {
+  return span.capturePolicy?.mask ?? true;
+}
+
+function isCut(fields: SpanFields | undefined): boolean {
+  return fields?.attributes?.["telemetry.dev.capture.truncated"] === true;
+}
+
+// Cores older than captureMasked expose no mask policy before a span starts; treat them as
+// masked, like LEGACY_CAPTURE_POLICY. A namespace read keeps them loadable without the export.
+function captureMaskedBeforeStart(): boolean {
+  const read = (telemetrySdk as { captureMasked?: () => boolean }).captureMasked;
+
+  try {
+    return typeof read === "function" ? read() : true;
+  } catch {
+    return true;
+  }
+}
+
+// The decision is made before the span starts so samplers see the same attributes as before.
+function startRequestSpan(name: string, options: StartSpanOptions): SpanHandle {
+  const withheld = options.input !== undefined && isCut(options) && captureMaskedBeforeStart();
+
+  return startSpan(name, withheld ? { ...options, input: undefined } : options);
+}
+
+/** Ends a non-streamed span, withholding output cut to the retention bound from a mask. */
+export function endSpanWithBoundedOutput(span: SpanHandle, fields: SpanFields): void {
+  const withheld = fields.output !== undefined && isCut(fields) && capturesWithMask(span);
+
+  endSpan(span, withheld ? { ...fields, output: undefined } : fields);
+}
+
 export function endSpan(span: SpanHandle, fields?: SpanFields): void {
   try {
     span.end(withCacheInclusiveInput(fields));
@@ -306,9 +350,69 @@ export function parseJson<T>(value: T): JsonValue {
   }
 }
 
+// Retention uses fixed bounds; the core applies maxAttributeLength after the mask.
+export const STREAM_CAPTURE_MAX_BYTES = 48 * 1024;
+export const STREAM_CAPTURE_MAX_ITEMS = 1_000;
+const CAPTURE_TRUNCATED_ATTRIBUTE = "telemetry.dev.capture.truncated";
+
+// Older cores enforce captureOutput and masking when the span ends but expose no policy, so
+// withhold incomplete output from their mask. Retention uses the fixed stream bounds either way;
+// maxAttributeLength is only here to satisfy the policy type.
+const LEGACY_CAPTURE_POLICY: NonNullable<SpanHandle["capturePolicy"]> = {
+  output: true,
+  mask: true,
+  maxAttributeLength: 65_536,
+};
+
+/** Tracks the fixed byte and item bound before a stream state retains a value. */
+export class StreamRetention {
+  private bytes = 0;
+  private items = 0;
+  truncated = false;
+
+  accept<T>(value: T): boolean {
+    if (this.truncated) return false;
+
+    const measured = boundedCaptureDetails(value, {
+      maxBytes: STREAM_CAPTURE_MAX_BYTES - this.bytes,
+      maxItems: STREAM_CAPTURE_MAX_ITEMS - this.items,
+    });
+
+    if (measured.truncated) {
+      this.truncated = true;
+
+      return false;
+    }
+
+    this.bytes += measured.bytes;
+    this.items += measured.items;
+
+    return true;
+  }
+}
+
 export interface StreamState {
   feed<T>(event: T): boolean | void;
   finish(partial: boolean): SpanFields;
+  readonly retention: StreamRetention;
+  /** Whether the exported output itself was cut; defaults to the retention flag. */
+  outputTruncated?(): boolean;
+}
+
+function finishStream(state: StreamState, span: SpanHandle, partial: boolean): SpanFields {
+  const fields = state.finish(partial);
+  const interrupted = partial || fields.error !== undefined;
+
+  if (!interrupted && !state.retention.truncated) return fields;
+
+  fields.attributes = { ...fields.attributes, [CAPTURE_TRUNCATED_ATTRIBUTE]: true };
+  const outputTruncated = state.outputTruncated?.() ?? state.retention.truncated;
+
+  if ((span.capturePolicy ?? LEGACY_CAPTURE_POLICY).mask && (interrupted || outputTruncated)) {
+    delete fields.output;
+  }
+
+  return fields;
 }
 
 export function wrapAsyncIterable<T>(
@@ -360,13 +464,13 @@ export function wrapAsyncIterable<T>(
       completed = true;
     } catch (error) {
       endOnce(
-        mergeFields(state.finish(true), awsMetadataFields(metadataOf(error)), {
+        mergeFields(finishStream(state, span, true), awsMetadataFields(metadataOf(error)), {
           error: asError(error),
         }),
       );
       throw error;
     } finally {
-      if (!ended) endOnce(state.finish(!completed));
+      if (!ended) endOnce(finishStream(state, span, !completed));
     }
   };
 
@@ -378,7 +482,7 @@ export function wrapAsyncIterable<T>(
     }
   }
 
-  const finishAbandoned = () => endOnce(safe(() => state.finish(true)));
+  const finishAbandoned = () => endOnce(safe(() => finishStream(state, span, true)));
   wrapped[Symbol.asyncIterator] = () => {
     const iterator = generator();
     STREAM_FINALIZER?.register(iterator, finishAbandoned, unregisterToken);

package/src/invoke-model.ts

@@ -11,6 +11,7 @@ import {
   parseJson,
   PROVIDER,
   stringValue,
+  StreamRetention,
   type JsonRecord,
   type JsonValue,
   type StreamState,
@@ -251,6 +252,7 @@ function headerNumber<T>(value: T): number | undefined {
 }
 
 export class InvokeModelStreamState implements StreamState {
+  readonly retention = new StreamRetention();
   private readonly chunks: unknown[] = [];
   private text = "";
   private usage: SpanFields["usage"];
@@ -277,8 +279,10 @@ export class InvokeModelStreamState implements StreamState {
       return (typeof raw === "string" || raw instanceof Uint8Array) && raw.length > 0;
     }
 
-    this.chunks.push(parsed);
-    this.text += textFromProviderChunk(parsed);
+    if (this.retention.accept(parsed)) {
+      this.chunks.push(parsed);
+      this.text += textFromProviderChunk(parsed);
+    }
 
     if (isRecord(parsed)) {
       const delta = isRecord(parsed.delta) ? parsed.delta : undefined;