@telemetry-dev/bedrock 0.1.9 → 0.1.12

package/README.md

@@ -2,6 +2,8 @@
 
 First-class AWS Bedrock instrumentation for the telemetry.dev TypeScript SDK.
 
+Docs: https://telemetry.dev/docs/integrations/bedrock
+
 This package instruments AWS SDK for JavaScript v3 clients for:
 
 - `@aws-sdk/client-bedrock-runtime`
@@ -29,15 +31,18 @@ pnpm add @telemetry-dev/sdk @telemetry-dev/bedrock @aws-sdk/client-bedrock-runti
 pnpm add @aws-sdk/client-bedrock-agent-runtime
 ```
 
+Requires `@aws-sdk/client-bedrock-runtime` 3.600.0 or a later 3.x release (and the same range for the optional `@aws-sdk/client-bedrock-agent-runtime`), and `@telemetry-dev/sdk`, which needs Node.js 20.19.0 or later.
+
 ## Quickstart
 
+`init()` reads your project API key from the `TELEMETRY_DEV_API_KEY` environment variable, so set it before you start the app.
+
 ```ts
 import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
 import { init, shutdown } from "@telemetry-dev/sdk";
 import { wrapBedrock } from "@telemetry-dev/bedrock";
 
 init({
-  apiKey: process.env.TELEMETRY_DEV_API_KEY,
   serviceName: "bedrock-app",
   environment: "production",
 });
@@ -98,9 +103,22 @@ instrumentBedrockAgents({ captureAgentTrace: false });
 
 ## Options
 
-| Option              | Default | Applies to            | Notes                                                                                                                                                 |
-| ------------------- | ------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `captureAgentTrace` | `false` | Agent Runtime streams | Aggregates trace usage and counts by default. When enabled, also attaches raw trace events as `td.metadata.agent_trace` after SDK masking/truncation. |
+| Option              | Default | Applies to            | Notes                                                                                                                                             |
+| ------------------- | ------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `captureAgentTrace` | `false` | Agent Runtime streams | Aggregates trace usage and counts by default. When enabled, also attaches trace events as `td.metadata.agent_trace`, filtered as described below. |
+
+`td.metadata.agent_trace` is truncated but never passed to your `mask`, so each trace event is rebuilt from an explicit allowlist instead:
+
+- Envelope fields: `agentId`, `agentAliasId`, `agentVersion`, `sessionId`, `collaboratorName`, `eventTime`, and the alias ARNs in `callerChain`.
+- Content the agent sends to a model, tool, or guardrail (`modelInvocationInput`, `invocationInput`, `inputAssessments`) is kept as received when `captureInput` is on.
+- Content that comes back (`modelInvocationOutput`, `rationale`, `observation`, `outputAssessments`, custom orchestration `event`) is kept as received when `captureOutput` is on.
+- A failure reason (`failureTrace.failureReason`, and `td.metadata.failure_reason`) is free-form text, so it is kept only when both are on. `td.metadata.failure` always records that the invocation failed, with `td.metadata.failure_code` when AWS sends one.
+- When a `mask` is set, all of this content is withheld.
+- Withheld content and the trace structure around it keep only trace ids, step types, the foundation model, guardrail action, failure code, and the usage, timings, and `clientRequestId` from AWS's trace `metadata`.
+
+Any other field, including unknown trace types and the AWS SDK's `$unknown` union member, is omitted even when both capture options are on; a content part that is kept is exported whole, including any fields inside it that are not listed here. Errors are not covered by this filtering: AWS exceptions, including errors raised inside the stream, still record the provider's error message on the span.
+
+Output file names in `td.metadata.output_files` follow `captureOutput` the same way, and are withheld when a `mask` is set; file types are always kept.
 
 ## Signal coverage
 
@@ -138,8 +156,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
@@ -156,3 +177,7 @@ The following calls pass through unless a supported operation above is used:
 - `AgenticRetrieveStream`
 
 Provider-native `InvokeModel` usage is best-effort. Anthropic Claude, Amazon Titan/Nova, Meta Llama, and Titan embeddings expose known token fields. Cohere and Mistral text models do not consistently include usage in the JSON body; spans still capture request/response bodies and finish reasons where present.
+
+## License
+
+MIT. See [LICENSE](https://github.com/telemetry-dev/telemetry/blob/main/packages/bedrock/LICENSE).

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-CLP2wXDh.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-CLP2wXDh.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-CLP2wXDh.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,17 +408,27 @@ function inlineAgentRequestFields(input) {
 	});
 }
 var AgentStreamState = class {
+	retention = new StreamRetention();
 	text = "";
+	textRejected = false;
 	usage = {};
 	traceEventCount = 0;
+	failed = false;
+	failureCode;
 	failureReason;
 	guardrailAction;
 	returnControl;
+	sawReturnControl = false;
+	returnControlRejected = false;
 	traces = [];
 	error;
 	errorFields;
 	citationCount = 0;
 	outputFiles = [];
+	contentCapture = {
+		input: captureEnabled("input") && !captureMaskedBeforeStart(),
+		output: captureEnabled("output") && !captureMaskedBeforeStart()
+	};
 	constructor(options) {
 		this.options = options;
 	}
@@ -365,30 +443,58 @@ 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((file) => sanitizeOutputFile(file, this.contentCapture.output));
+		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);
-			collectTrace(traceEvent, (usage) => this.addUsage(usage));
-			const failure = findKey(traceEvent, "failureTrace");
-			if (isRecord(failure)) this.failureReason = stringValue(failure.failureReason) ?? this.failureReason;
-			const guardrail = findKey(traceEvent, "guardrailTrace");
+			if (this.options.captureAgentTrace) {
+				const retained = projectTrace(traceEvent, TRACE_PART, this.contentCapture);
+				if (this.retention.accept(retained)) this.traces.push(retained);
+			}
+			const trace = isRecord(traceEvent.trace) ? traceEvent.trace : {};
+			for (const step of MODEL_INVOCATION_STEPS) {
+				const member = isRecord(trace[step]) ? trace[step] : void 0;
+				const output = isRecord(member?.modelInvocationOutput) ? member.modelInvocationOutput : {};
+				this.addUsage(isRecord(output.metadata) ? output.metadata.usage : void 0);
+			}
+			const failure = trace.failureTrace;
+			if (isRecord(failure)) {
+				this.failed = true;
+				this.failureCode = numberValue(failure.failureCode) ?? this.failureCode;
+				if (this.contentCapture.input && this.contentCapture.output) this.failureReason = stringValue(failure.failureReason) ?? this.failureReason;
+			}
+			const guardrail = trace.guardrailTrace;
 			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: this.failed ? true : void 0,
+			failure_code: this.failureCode,
 			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
@@ -418,11 +524,11 @@ var AgentStreamState = class {
 		else if (inputTokens !== void 0 || outputTokens !== void 0) this.usage.totalTokens = (this.usage.inputTokens ?? 0) + (this.usage.outputTokens ?? 0);
 	}
 };
-function sanitizeOutputFile(value) {
+function sanitizeOutputFile(value, keepName) {
 	const raw = value;
 	if (!isRecord(raw)) return void 0;
 	return omitUndefined({
-		name: stringValue(raw.name),
+		name: keepName ? stringValue(raw.name) : void 0,
 		type: stringValue(raw.type)
 	});
 }
@@ -533,6 +639,7 @@ function ragResponseFields(output) {
 	});
 }
 var RagStreamState = class {
+	retention = new StreamRetention();
 	text = "";
 	citationCount = 0;
 	guardrailAction;
@@ -547,8 +654,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 +685,7 @@ function flowRequestFields(input) {
 	});
 }
 var FlowStreamState = class {
+	retention = new StreamRetention();
 	outputs = [];
 	completionReason;
 	error;
@@ -592,9 +700,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;
 	}
@@ -612,22 +720,111 @@ function flowName(input) {
 function ragName(input) {
 	return `retrieve_and_generate ${basenameArn(ragModel(input)) ?? "knowledge-base"}`;
 }
-function collectTrace(value, onUsage) {
-	const raw = value;
-	if (!isRecord(raw)) return;
-	const output = isRecord(raw.modelInvocationOutput) ? raw.modelInvocationOutput : void 0;
-	if (output) onUsage((isRecord(output.metadata) ? output.metadata : void 0)?.usage);
-	for (const child of Object.values(raw)) if (isRecord(child)) collectTrace(child, onUsage);
-	else if (Array.isArray(child)) child.forEach((item) => collectTrace(item, onUsage));
-}
-function findKey(value, key) {
-	const raw = value;
-	if (!isRecord(raw)) return void 0;
-	if (raw[key] !== void 0) return raw[key];
-	for (const child of Object.values(raw)) {
-		const found = findKey(child, key);
-		if (found !== void 0) return found;
+/** Content kept as received when every listed capture is on; otherwise reduced to `withheld`. */
+var TraceContent = class {
+	constructor(needs, withheld) {
+		this.needs = needs;
+		this.withheld = withheld;
+	}
+};
+const SCALAR = "scalar";
+const TRACE_METADATA = {
+	usage: {
+		inputTokens: SCALAR,
+		outputTokens: SCALAR
+	},
+	startTime: SCALAR,
+	endTime: SCALAR,
+	totalTimeMs: SCALAR,
+	operationTotalTimeMs: SCALAR,
+	clientRequestId: SCALAR
+};
+const MODEL_INVOCATION_INPUT = new TraceContent(["input"], {
+	traceId: SCALAR,
+	type: SCALAR,
+	foundationModel: SCALAR
+});
+const INVOCATION_INPUT = new TraceContent(["input"], {
+	traceId: SCALAR,
+	invocationType: SCALAR
+});
+const MODEL_INVOCATION_OUTPUT = new TraceContent(["output"], {
+	traceId: SCALAR,
+	metadata: TRACE_METADATA
+});
+const OBSERVATION = new TraceContent(["output"], {
+	traceId: SCALAR,
+	type: SCALAR
+});
+const MODEL_INVOCATION_STEPS = [
+	"preProcessingTrace",
+	"orchestrationTrace",
+	"postProcessingTrace",
+	"routingClassifierTrace"
+];
+const PROCESSING_TRACE = {
+	modelInvocationInput: MODEL_INVOCATION_INPUT,
+	modelInvocationOutput: MODEL_INVOCATION_OUTPUT
+};
+const TRACE_PART = {
+	agentId: SCALAR,
+	agentAliasId: SCALAR,
+	agentVersion: SCALAR,
+	sessionId: SCALAR,
+	collaboratorName: SCALAR,
+	eventTime: SCALAR,
+	callerChain: [{ agentAliasArn: SCALAR }],
+	trace: {
+		preProcessingTrace: PROCESSING_TRACE,
+		postProcessingTrace: PROCESSING_TRACE,
+		orchestrationTrace: {
+			modelInvocationInput: MODEL_INVOCATION_INPUT,
+			invocationInput: INVOCATION_INPUT,
+			modelInvocationOutput: MODEL_INVOCATION_OUTPUT,
+			rationale: new TraceContent(["output"], { traceId: SCALAR }),
+			observation: OBSERVATION
+		},
+		routingClassifierTrace: {
+			modelInvocationInput: MODEL_INVOCATION_INPUT,
+			invocationInput: INVOCATION_INPUT,
+			modelInvocationOutput: MODEL_INVOCATION_OUTPUT,
+			observation: OBSERVATION
+		},
+		customOrchestrationTrace: {
+			traceId: SCALAR,
+			event: new TraceContent(["output"])
+		},
+		guardrailTrace: {
+			traceId: SCALAR,
+			action: SCALAR,
+			metadata: TRACE_METADATA,
+			inputAssessments: new TraceContent(["input"]),
+			outputAssessments: new TraceContent(["output"])
+		},
+		failureTrace: {
+			traceId: SCALAR,
+			failureCode: SCALAR,
+			metadata: TRACE_METADATA,
+			failureReason: new TraceContent(["input", "output"])
+		}
+	}
+};
+function projectTrace(value, shape, capture) {
+	if (shape instanceof TraceContent) {
+		if (shape.needs.every((kind) => capture[kind])) return value ?? void 0;
+		return shape.withheld === void 0 ? void 0 : projectTrace(value, shape.withheld, capture);
+	}
+	if (shape === SCALAR) return [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value) || value instanceof Date ? value : void 0;
+	if (Array.isArray(shape)) {
+		if (!Array.isArray(value)) return void 0;
+		return value.map((item) => projectTrace(item, shape[0], capture)).filter((item) => item !== void 0);
 	}
+	if (!isRecord(value)) return void 0;
+	return omitUndefined(Object.fromEntries(Object.entries(shape).map(([field, child]) => [field, projectTrace(value[field], child, capture)])));
 }
 //#endregion
 //#region src/converse.ts
@@ -801,6 +998,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 +1018,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 +1045,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: ""
@@ -1058,12 +1256,7 @@ function nativeResponseFields(model, body, metadata) {
 		return withHeaderUsage({
 			output: body,
 			finishReason: stringValue(body.stop_reason),
-			usage: omitUndefined({
-				inputTokens: numberValue(usage.input_tokens),
-				outputTokens: numberValue(usage.output_tokens),
-				cacheReadInputTokens: numberValue(usage.cache_read_input_tokens),
-				cacheCreationInputTokens: numberValue(usage.cache_creation_input_tokens)
-			})
+			...claudeUsageFields(usage)
 		}, metadata);
 	}
 	if (lower.includes("meta.llama")) return omitUndefined({
@@ -1088,6 +1281,35 @@ function nativeResponseFields(model, body, metadata) {
 	}, metadata);
 	return withHeaderUsage({ output: body }, metadata);
 }
+const CLAUDE_USAGE_KEYS = {
+	inputTokens: "input_tokens",
+	outputTokens: "output_tokens",
+	cacheReadInputTokens: "cache_read_input_tokens",
+	cacheCreationInputTokens: "cache_creation_input_tokens"
+};
+function claudeUsageFields(record) {
+	const usage = {};
+	for (const [key, source] of Object.entries(CLAUDE_USAGE_KEYS)) {
+		const value = numberValue(record[source]);
+		if (value !== void 0) usage[key] = value;
+	}
+	const iterations = record.iterations;
+	if (!Array.isArray(iterations)) return { usage };
+	const first = Math.max(0, iterations.length - STREAM_CAPTURE_MAX_ITEMS);
+	for (let index = first; index < iterations.length; index += 1) {
+		const entry = iterations[index];
+		if (!isRecord(entry) || entry.type !== "compaction") continue;
+		for (const [key, source] of Object.entries(CLAUDE_USAGE_KEYS)) {
+			const value = numberValue(entry[source]);
+			const target = key;
+			if (value !== void 0) usage[target] = (usage[target] ?? 0) + value;
+		}
+	}
+	return {
+		usage,
+		...first > 0 ? { attributes: { "telemetry.dev.capture.truncated": true } } : {}
+	};
+}
 function withHeaderUsage(fields, metadata) {
 	if (fields.usage && Object.keys(fields.usage).length > 0) return fields;
 	return mergeFields(fields, headerUsageFields(metadata));
@@ -1109,9 +1331,13 @@ function headerNumber(value) {
 	return numberValue(value);
 }
 var InvokeModelStreamState = class {
+	retention = new StreamRetention();
 	chunks = [];
 	text = "";
 	usage;
+	finalUsage = {};
+	startUsage = {};
+	compaction = {};
 	finishReason;
 	error;
 	errorFields;
@@ -1129,28 +1355,53 @@ 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;
 			const messageUsage = isRecord(message?.usage) ? message?.usage : void 0;
 			const usage = isRecord(parsed.usage) ? parsed.usage : void 0;
+			for (const [key, source] of Object.entries(CLAUDE_USAGE_KEYS)) {
+				const value = numberValue(usage?.[source]);
+				if (value !== void 0) this.finalUsage[key] = value;
+			}
+			this.startUsage = omitUndefined({
+				...this.startUsage,
+				inputTokens: numberValue(messageUsage?.input_tokens) ?? this.startUsage.inputTokens,
+				outputTokens: numberValue(messageUsage?.output_tokens) ?? this.startUsage.outputTokens,
+				cacheReadInputTokens: numberValue(messageUsage?.cache_read_input_tokens) ?? this.startUsage.cacheReadInputTokens,
+				cacheCreationInputTokens: numberValue(messageUsage?.cache_creation_input_tokens) ?? this.startUsage.cacheCreationInputTokens
+			});
+			const iterations = Array.isArray(usage?.iterations) ? usage.iterations : messageUsage?.iterations;
+			if (Array.isArray(iterations)) this.compaction = claudeUsageFields({ iterations });
 			const metrics = isRecord(parsed["amazon-bedrock-invocationMetrics"]) ? parsed["amazon-bedrock-invocationMetrics"] : void 0;
 			const outputs = Array.isArray(parsed.outputs) && isRecord(parsed.outputs[0]) ? parsed.outputs[0] : void 0;
 			const generation = Array.isArray(parsed.generations) && isRecord(parsed.generations[0]) ? parsed.generations[0] : void 0;
 			this.finishReason = stringValue(delta?.stop_reason) ?? stringValue(parsed.stop_reason) ?? stringValue(outputs?.stop_reason) ?? stringValue(generation?.finish_reason) ?? stringValue(parsed.completionReason) ?? this.finishReason;
 			this.usage = omitUndefined({
 				...this.usage,
-				inputTokens: numberValue(messageUsage?.input_tokens) ?? numberValue(metrics?.inputTokenCount) ?? numberValue(parsed.inputTextTokenCount) ?? this.usage?.inputTokens,
+				inputTokens: numberValue(usage?.input_tokens) ?? numberValue(metrics?.inputTokenCount) ?? numberValue(parsed.inputTextTokenCount) ?? this.usage?.inputTokens,
 				outputTokens: numberValue(usage?.output_tokens) ?? numberValue(metrics?.outputTokenCount) ?? numberValue(parsed.totalOutputTextTokenCount) ?? this.usage?.outputTokens,
-				cacheReadInputTokens: numberValue(messageUsage?.cache_read_input_tokens) ?? this.usage?.cacheReadInputTokens,
-				cacheCreationInputTokens: numberValue(messageUsage?.cache_creation_input_tokens) ?? this.usage?.cacheCreationInputTokens
+				cacheReadInputTokens: numberValue(usage?.cache_read_input_tokens) ?? this.usage?.cacheReadInputTokens,
+				cacheCreationInputTokens: numberValue(usage?.cache_creation_input_tokens) ?? this.usage?.cacheCreationInputTokens
 			});
 		}
 		return providerChunkHasOutput(parsed);
 	}
 	finish() {
+		const usage = {
+			...this.startUsage,
+			...this.usage,
+			...this.finalUsage
+		};
+		for (const key of Object.keys(CLAUDE_USAGE_KEYS)) {
+			const value = this.compaction.usage?.[key];
+			const baseKey = key === "outputTokens" ? "outputTokens" : "inputTokens";
+			if (value !== void 0 && (this.finalUsage[baseKey] !== void 0 || this.usage?.[baseKey] === void 0)) usage[key] = (usage[key] ?? 0) + value;
+		}
 		return mergeFields(omitUndefined({
 			output: this.text ? [{
 				role: "assistant",
@@ -1161,7 +1412,8 @@ var InvokeModelStreamState = class {
 				finish_reason: this.finishReason
 			}] : this.chunks,
 			finishReason: this.finishReason,
-			usage: this.usage,
+			usage,
+			attributes: this.compaction.attributes,
 			error: this.error
 		}), this.errorFields);
 	}
@@ -1278,7 +1530,7 @@ const AGENT_HANDLERS = {
 		spanType: () => "span",
 		requestFields: rerankRequestFields,
 		onResult(result, span) {
-			endSpan(span, rerankResponseFields(result));
+			endSpanWithBoundedOutput(span, rerankResponseFields(result));
 			return result;
 		}
 	},