@telemetry-dev/bedrock 0.1.0

package/dist/internal-handlers-BloMjBP8.mjs

@@ -0,0 +1,1201 @@
+import { 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;
+function createInstrumentedSend(originalSend, options, handlers) {
+	return function instrumentedSend(command, ...rest) {
+		const name = command?.constructor?.name;
+		const handler = typeof name === "string" ? handlers[name] : void 0;
+		if (!handler) return originalSend.apply(this, [command, ...rest]);
+		const input = commandInput(command);
+		const t0 = performance.now();
+		const spanType = safe(() => handler.spanType(input)) ?? "span";
+		const span = startSpan(safe(() => handler.spanName(input)) ?? name ?? "bedrock", {
+			type: spanType,
+			...safe(() => handler.requestFields(input, options)) ?? {}
+		});
+		const callbackIndex = rest.findIndex((arg) => typeof arg === "function");
+		if (callbackIndex !== -1) {
+			const callback = rest[callbackIndex];
+			const wrappedRest = [...rest];
+			wrappedRest[callbackIndex] = (error, data) => {
+				if (error != null) {
+					endSpan(span, {
+						...awsMetadataFields(metadataOf(error)),
+						error
+					});
+					callback(error, data);
+					return;
+				}
+				let nextData = data;
+				try {
+					nextData = handler.onResult(data, span, t0, input, options);
+				} catch {
+					endSpan(span, awsMetadataFields(metadataOf(data)));
+				}
+				callback(error, nextData);
+			};
+			try {
+				return originalSend.apply(this, [command, ...wrappedRest]);
+			} catch (error) {
+				endSpan(span, {
+					...awsMetadataFields(metadataOf(error)),
+					error
+				});
+				throw error;
+			}
+		}
+		let result;
+		try {
+			result = originalSend.apply(this, [command, ...rest]);
+		} catch (error) {
+			endSpan(span, {
+				...awsMetadataFields(metadataOf(error)),
+				error
+			});
+			throw error;
+		}
+		return Promise.resolve(result).then((resolved) => {
+			try {
+				return handler.onResult(resolved, span, t0, input, options);
+			} catch {
+				endSpan(span, awsMetadataFields(metadataOf(resolved)));
+				return resolved;
+			}
+		}, (error) => {
+			endSpan(span, {
+				...awsMetadataFields(metadataOf(error)),
+				error
+			});
+			throw error;
+		});
+	};
+}
+function commandInput(command) {
+	const value = command?.input;
+	return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safe(fn) {
+	try {
+		return fn();
+	} catch {
+		return;
+	}
+}
+function endSpan(span, fields) {
+	try {
+		span.end(fields);
+	} catch {}
+}
+function updateSpan(span, fields) {
+	try {
+		span.update(fields);
+	} catch {}
+}
+function metadataOf(value) {
+	if (isRecord(value) && isRecord(value.$metadata)) return value.$metadata;
+	return value?.$metadata;
+}
+function modeledStreamError(event) {
+	for (const [key, name] of Object.entries({
+		accessDeniedException: "AccessDeniedException",
+		badGatewayException: "BadGatewayException",
+		conflictException: "ConflictException",
+		dependencyFailedException: "DependencyFailedException",
+		internalServerException: "InternalServerException",
+		modelNotReadyException: "ModelNotReadyException",
+		modelStreamErrorException: "ModelStreamErrorException",
+		modelTimeoutException: "ModelTimeoutException",
+		resourceNotFoundException: "ResourceNotFoundException",
+		serviceQuotaExceededException: "ServiceQuotaExceededException",
+		serviceUnavailableException: "ServiceUnavailableException",
+		throttlingException: "ThrottlingException",
+		validationException: "ValidationException"
+	})) {
+		const exception = isRecord(event[key]) ? event[key] : void 0;
+		if (!exception) continue;
+		const error = new Error(stringValue(exception.message) ?? stringValue(exception.originalMessage) ?? name);
+		error.name = stringValue(exception.name) ?? name;
+		return {
+			error,
+			fields: awsMetadataFields(exception.$metadata)
+		};
+	}
+}
+function awsMetadataFields(metadata) {
+	if (!isRecord(metadata)) return {};
+	const requestId = stringValue(metadata.requestId);
+	const attempts = numberValue(metadata.attempts);
+	const httpStatusCode = numberValue(metadata.httpStatusCode);
+	const totalRetryDelay = numberValue(metadata.totalRetryDelay);
+	const attributes = {};
+	if (httpStatusCode !== void 0) attributes["aws.http.status_code"] = httpStatusCode;
+	if (attempts !== void 0 && attempts > 1) attributes["aws.request.attempts"] = attempts;
+	if (totalRetryDelay !== void 0) attributes["aws.request.total_retry_delay_ms"] = totalRetryDelay;
+	return omitUndefined({
+		responseId: requestId,
+		attributes: Object.keys(attributes).length > 0 ? attributes : void 0
+	});
+}
+function mergeFields(...fields) {
+	const merged = {};
+	for (const field of fields) {
+		if (!field) continue;
+		const { metadata, attributes, usage, ...rest } = field;
+		Object.assign(merged, omitUndefined(rest));
+		if (usage) merged.usage = {
+			...merged.usage,
+			...usage
+		};
+		if (metadata) merged.metadata = {
+			...merged.metadata,
+			...metadata
+		};
+		if (attributes) merged.attributes = {
+			...merged.attributes,
+			...attributes
+		};
+	}
+	return merged;
+}
+function omitUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function stringValue(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function arrayValue(value) {
+	return Array.isArray(value) ? value : void 0;
+}
+function bytesToString(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Uint8Array) return new TextDecoder().decode(value);
+	if (ArrayBuffer.isView(value)) return new TextDecoder().decode(value);
+}
+function parseJson(value) {
+	const text = bytesToString(value);
+	if (text === void 0) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+function wrapAsyncIterable(iterable, state, span, t0, baseFields) {
+	if (!iterable || typeof iterable[Symbol.asyncIterator] !== "function") {
+		endSpan(span, baseFields);
+		return iterable;
+	}
+	let ended = false;
+	let first = false;
+	const unregisterToken = {};
+	const endOnce = (fields) => {
+		if (ended) return;
+		ended = true;
+		STREAM_FINALIZER?.unregister(unregisterToken);
+		endSpan(span, mergeFields(baseFields, fields));
+	};
+	const source = iterable;
+	const generator = async function* () {
+		let completed = false;
+		try {
+			for await (const event of source) {
+				if (!first) {
+					first = true;
+					updateSpan(span, { timeToFirstChunkMs: performance.now() - t0 });
+				}
+				safe(() => state.feed(event));
+				yield event;
+			}
+			completed = true;
+		} catch (error) {
+			endOnce(mergeFields(state.finish(true), awsMetadataFields(metadataOf(error)), { error }));
+			throw error;
+		} finally {
+			if (!ended) endOnce(state.finish(!completed));
+		}
+	};
+	const wrapped = {};
+	if (isRecord(iterable)) for (const key of Reflect.ownKeys(iterable)) wrapped[key] = iterable[key];
+	const finishAbandoned = () => endOnce(safe(() => state.finish(true)));
+	wrapped[Symbol.asyncIterator] = () => {
+		const iterator = generator();
+		STREAM_FINALIZER?.register(iterator, finishAbandoned, unregisterToken);
+		return iterator;
+	};
+	STREAM_FINALIZER?.register(wrapped, finishAbandoned, unregisterToken);
+	return wrapped;
+}
+function basenameArn(value) {
+	const text = stringValue(value);
+	if (!text) return void 0;
+	return text.split(/[/:]/).filter(Boolean).at(-1) ?? text;
+}
+//#endregion
+//#region src/agent-handlers.ts
+function agentInputMessages(inputText) {
+	const text = stringValue(inputText);
+	return text ? [{
+		role: "user",
+		parts: [{
+			type: "text",
+			content: text
+		}]
+	}] : void 0;
+}
+function agentRequestFields(input) {
+	return omitUndefined({
+		provider: PROVIDER,
+		input: agentInputMessages(input.inputText),
+		agentId: stringValue(input.agentId),
+		metadata: omitUndefined({
+			bedrock_agent_alias_id: stringValue(input.agentAliasId),
+			bedrock_session_id: stringValue(input.sessionId),
+			bedrock_memory_id: stringValue(input.memoryId)
+		})
+	});
+}
+function inlineAgentRequestFields(input) {
+	return omitUndefined({
+		input: agentInputMessages(input.inputText),
+		model: stringValue(input.foundationModel),
+		provider: PROVIDER,
+		agentName: stringValue(input.agentName),
+		metadata: omitUndefined({ bedrock_session_id: stringValue(input.sessionId) })
+	});
+}
+var AgentStreamState = class {
+	text = "";
+	usage = {};
+	traceEventCount = 0;
+	failureReason;
+	guardrailAction;
+	returnControl;
+	traces = [];
+	error;
+	errorFields;
+	citationCount = 0;
+	outputFiles = [];
+	constructor(options) {
+		this.options = options;
+	}
+	feed(event) {
+		if (!isRecord(event)) return;
+		const streamError = modeledStreamError(event);
+		if (streamError) {
+			this.error = streamError.error;
+			this.errorFields = streamError.fields;
+			return;
+		}
+		const chunk = isRecord(event.chunk) ? event.chunk : void 0;
+		const bytes = chunk?.bytes;
+		if (bytes !== void 0) this.text += bytesToString(bytes) ?? "";
+		const citations = arrayValue((isRecord(chunk?.attribution) ? chunk.attribution : void 0)?.citations);
+		if (citations) this.citationCount += citations.length;
+		const files = isRecord(event.files) ? arrayValue(event.files.files) : void 0;
+		if (files) this.outputFiles.push(...files.map(sanitizeOutputFile));
+		const returnControl = isRecord(event.returnControl) ? event.returnControl : void 0;
+		if (returnControl) this.returnControl = returnControl;
+		const traceEvent = isRecord(event.trace) ? event.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 (isRecord(guardrail)) this.guardrailAction = stringValue(guardrail.action) ?? this.guardrailAction;
+		}
+	}
+	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,
+			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
+		});
+		return mergeFields(omitUndefined({
+			output: this.returnControl ? { returnControl: this.returnControl } : this.text ? [{
+				role: "assistant",
+				parts: [{
+					type: "text",
+					content: this.text
+				}]
+			}] : void 0,
+			usage: Object.keys(this.usage).length > 0 ? this.usage : void 0,
+			metadata,
+			error: this.error
+		}), this.errorFields);
+	}
+	addUsage(value) {
+		if (!isRecord(value)) return;
+		const inputTokens = numberValue(value.inputTokens);
+		const outputTokens = numberValue(value.outputTokens);
+		const totalTokens = numberValue(value.totalTokens);
+		if (inputTokens !== void 0) this.usage.inputTokens = (this.usage.inputTokens ?? 0) + inputTokens;
+		if (outputTokens !== void 0) this.usage.outputTokens = (this.usage.outputTokens ?? 0) + outputTokens;
+		if (totalTokens !== void 0) this.usage.totalTokens = (this.usage.totalTokens ?? 0) + totalTokens;
+		else if (inputTokens !== void 0 || outputTokens !== void 0) this.usage.totalTokens = (this.usage.inputTokens ?? 0) + (this.usage.outputTokens ?? 0);
+	}
+};
+function sanitizeOutputFile(value) {
+	if (!isRecord(value)) return value;
+	return omitUndefined({
+		name: stringValue(value.name),
+		type: stringValue(value.type)
+	});
+}
+function retrieveRequestFields(input) {
+	return omitUndefined({
+		provider: PROVIDER,
+		input: isRecord(input.retrievalQuery) ? input.retrievalQuery : void 0,
+		metadata: { knowledge_base_id: stringValue(input.knowledgeBaseId) }
+	});
+}
+function retrieveResponseFields(output) {
+	const result = isRecord(output) ? output : {};
+	const retrievalResults = arrayValue(result.retrievalResults);
+	return mergeFields(awsMetadataFields(result.$metadata), {
+		output: retrievalResults,
+		metadata: omitUndefined({
+			citation_count: retrievalResults?.length,
+			guardrail_action: stringValue(result.guardrailAction)
+		})
+	});
+}
+function ragModel(input) {
+	const config = isRecord(input.retrieveAndGenerateConfiguration) ? input.retrieveAndGenerateConfiguration : void 0;
+	const kb = isRecord(config?.knowledgeBaseConfiguration) ? config?.knowledgeBaseConfiguration : void 0;
+	const external = isRecord(config?.externalSourcesConfiguration) ? config?.externalSourcesConfiguration : void 0;
+	return stringValue(kb?.modelArn) ?? stringValue(external?.modelArn);
+}
+function ragRequestFields(input) {
+	const text = isRecord(input.input) ? stringValue(input.input.text) : void 0;
+	return omitUndefined({
+		provider: PROVIDER,
+		model: ragModel(input),
+		input: text ? [{
+			role: "user",
+			parts: [{
+				type: "text",
+				content: text
+			}]
+		}] : void 0,
+		metadata: omitUndefined({ bedrock_session_id: stringValue(input.sessionId) })
+	});
+}
+function ragResponseFields(output) {
+	const result = isRecord(output) ? output : {};
+	const text = isRecord(result.output) ? stringValue(result.output.text) : void 0;
+	return mergeFields(awsMetadataFields(result.$metadata), {
+		output: text ? [{
+			role: "assistant",
+			parts: [{
+				type: "text",
+				content: text
+			}]
+		}] : void 0,
+		metadata: omitUndefined({
+			citation_count: arrayValue(result.citations)?.length,
+			guardrail_action: stringValue(result.guardrailAction),
+			bedrock_session_id: stringValue(result.sessionId)
+		})
+	});
+}
+var RagStreamState = class {
+	text = "";
+	citationCount = 0;
+	guardrailAction;
+	error;
+	errorFields;
+	feed(event) {
+		if (!isRecord(event)) return;
+		const streamError = modeledStreamError(event);
+		if (streamError) {
+			this.error = streamError.error;
+			this.errorFields = streamError.fields;
+			return;
+		}
+		const output = isRecord(event.output) ? event.output : void 0;
+		this.text += stringValue(output?.text) ?? "";
+		if (event.citation) this.citationCount += 1;
+		const guardrail = isRecord(event.guardrail) ? event.guardrail : void 0;
+		this.guardrailAction = stringValue(guardrail?.action) ?? this.guardrailAction;
+	}
+	finish() {
+		return mergeFields(omitUndefined({
+			output: this.text ? [{
+				role: "assistant",
+				parts: [{
+					type: "text",
+					content: this.text
+				}]
+			}] : void 0,
+			metadata: omitUndefined({
+				citation_count: this.citationCount || void 0,
+				guardrail_action: this.guardrailAction
+			}),
+			error: this.error
+		}), this.errorFields);
+	}
+};
+function flowRequestFields(input) {
+	return omitUndefined({
+		provider: PROVIDER,
+		input: input.inputs,
+		agentId: stringValue(input.flowIdentifier)
+	});
+}
+var FlowStreamState = class {
+	outputs = [];
+	completionReason;
+	error;
+	errorFields;
+	feed(event) {
+		if (!isRecord(event)) return;
+		const streamError = modeledStreamError(event);
+		if (streamError) {
+			this.error = streamError.error;
+			this.errorFields = streamError.fields;
+			return;
+		}
+		const output = isRecord(event.flowOutputEvent) ? event.flowOutputEvent : void 0;
+		if (output) this.outputs.push(output.content);
+		const inputRequest = isRecord(event.flowMultiTurnInputRequestEvent) ? event.flowMultiTurnInputRequestEvent : void 0;
+		if (inputRequest) this.outputs.push(inputRequest.content);
+		const completion = isRecord(event.flowCompletionEvent) ? event.flowCompletionEvent : void 0;
+		this.completionReason = stringValue(completion?.completionReason) ?? this.completionReason;
+	}
+	finish() {
+		return mergeFields(omitUndefined({
+			output: this.outputs.length > 0 ? this.outputs : void 0,
+			finishReason: this.completionReason,
+			error: this.error
+		}), this.errorFields);
+	}
+};
+function flowName(input) {
+	return `invoke_flow ${stringValue(input.flowIdentifier) ?? "unknown"}`;
+}
+function ragName(input) {
+	return `retrieve_and_generate ${basenameArn(ragModel(input)) ?? "knowledge-base"}`;
+}
+function collectTrace(value, onUsage) {
+	if (!isRecord(value)) return;
+	const output = isRecord(value.modelInvocationOutput) ? value.modelInvocationOutput : void 0;
+	if (output) onUsage((isRecord(output.metadata) ? output.metadata : void 0)?.usage);
+	for (const child of Object.values(value)) if (isRecord(child)) collectTrace(child, onUsage);
+	else if (Array.isArray(child)) child.forEach((item) => collectTrace(item, onUsage));
+}
+function findKey(value, key) {
+	if (!isRecord(value)) return void 0;
+	if (value[key] !== void 0) return value[key];
+	for (const child of Object.values(value)) {
+		const found = findKey(child, key);
+		if (found !== void 0) return found;
+	}
+}
+//#endregion
+//#region src/converse.ts
+function converseRequestFields(input) {
+	const inference = isRecord(input.inferenceConfig) ? input.inferenceConfig : {};
+	const guardrail = isRecord(input.guardrailConfig) ? input.guardrailConfig : void 0;
+	return omitUndefined({
+		provider: PROVIDER,
+		model: stringValue(input.modelId),
+		input: normalizeMessages(input.messages),
+		systemInstructions: normalizeSystem(input.system),
+		temperature: numberValue(inference.temperature),
+		topP: numberValue(inference.topP),
+		maxTokens: numberValue(inference.maxTokens),
+		stopSequences: arrayValue(inference.stopSequences),
+		metadata: guardrail ? omitUndefined({
+			guardrail_id: stringValue(guardrail.guardrailIdentifier),
+			guardrail_version: stringValue(guardrail.guardrailVersion)
+		}) : void 0
+	});
+}
+function converseResponseFields(output) {
+	const result = isRecord(output) ? output : {};
+	const usage = usageFromConverse(result.usage);
+	const metrics = isRecord(result.metrics) ? result.metrics : void 0;
+	const trace = isRecord(result.trace) ? result.trace : void 0;
+	const promptRouter = isRecord(trace?.promptRouter) ? trace?.promptRouter : void 0;
+	const guardrail = isRecord(trace?.guardrail) ? trace?.guardrail : void 0;
+	const stopReason = stringValue(result.stopReason);
+	const message = isRecord(result.output) ? result.output.message : void 0;
+	return mergeFields(awsMetadataFields(result.$metadata), {
+		output: normalizeOutputMessage(message, stopReason),
+		usage,
+		finishReason: stopReason,
+		responseModel: stringValue(promptRouter?.invokedModelId),
+		metadata: omitUndefined({
+			server_latency_ms: numberValue(metrics?.latencyMs),
+			guardrail_action: stringValue(result.guardrailAction) ?? stringValue(guardrail?.action),
+			guardrail_action_reason: stringValue(guardrail?.actionReason)
+		})
+	});
+}
+function usageFromConverse(value) {
+	if (!isRecord(value)) return void 0;
+	return omitUndefined({
+		inputTokens: numberValue(value.inputTokens),
+		outputTokens: numberValue(value.outputTokens),
+		totalTokens: numberValue(value.totalTokens),
+		cacheReadInputTokens: numberValue(value.cacheReadInputTokens),
+		cacheCreationInputTokens: numberValue(value.cacheWriteInputTokens)
+	});
+}
+function normalizeMessages(value) {
+	const messages = arrayValue(value);
+	if (!messages) return void 0;
+	return messages.map((message) => ({
+		role: stringValue(message.role),
+		parts: normalizeContentList(message.content)
+	}));
+}
+function normalizeOutputMessage(value, finishReason) {
+	if (!isRecord(value)) return void 0;
+	return [omitUndefined({
+		role: stringValue(value.role),
+		parts: normalizeContentList(value.content),
+		finish_reason: finishReason
+	})];
+}
+function normalizeSystem(value) {
+	const blocks = arrayValue(value);
+	if (!blocks) return void 0;
+	const parts = blocks.flatMap((block) => normalizeContentBlock(block));
+	return parts.length > 0 ? parts : void 0;
+}
+function normalizeContentList(value) {
+	const blocks = arrayValue(value);
+	if (!blocks) return [];
+	return blocks.flatMap((block) => normalizeContentBlock(block));
+}
+function normalizeContentBlock(block) {
+	const text = stringValue(block.text);
+	if (text !== void 0) return [omitUndefined({
+		type: "text",
+		content: text,
+		citations: arrayValue(block.citations)
+	})];
+	const toolUse = isRecord(block.toolUse) ? block.toolUse : void 0;
+	if (toolUse) return [omitUndefined({
+		type: "tool_call",
+		id: stringValue(toolUse.toolUseId),
+		name: stringValue(toolUse.name),
+		arguments: toolUse.input
+	})];
+	const toolResult = isRecord(block.toolResult) ? block.toolResult : void 0;
+	if (toolResult) return [omitUndefined({
+		type: "tool_call_response",
+		id: stringValue(toolResult.toolUseId),
+		response: simplifyToolResult(toolResult.content)
+	})];
+	const reasoning = isRecord(block.reasoningContent) ? block.reasoningContent : void 0;
+	if (reasoning) return [{
+		type: "reasoning",
+		content: stringValue((isRecord(reasoning.reasoningText) ? reasoning.reasoningText : void 0)?.text) ?? (reasoning.redactedContent ? "[redacted]" : "")
+	}];
+	for (const modality of [
+		"image",
+		"document",
+		"video",
+		"audio"
+	]) {
+		const media = isRecord(block[modality]) ? block[modality] : void 0;
+		if (!media) continue;
+		const format = stringValue(media.format);
+		const source = isRecord(media.source) ? media.source : void 0;
+		if (source?.bytes !== void 0) return [omitUndefined({
+			type: "blob",
+			modality,
+			mime_type: format ? `${modality}/${format}` : void 0
+		})];
+		const s3 = isRecord(source?.s3Location) ? source?.s3Location : void 0;
+		const uri = stringValue(source?.uri) ?? stringValue(s3?.uri) ?? s3Uri(s3);
+		if (uri) return [omitUndefined({
+			type: "uri",
+			uri,
+			modality,
+			mime_type: format
+		})];
+	}
+	const citationsContent = isRecord(block.citationsContent) ? block.citationsContent : void 0;
+	if (citationsContent) {
+		const contentBlocks = arrayValue(citationsContent.content) ?? [];
+		const citations = arrayValue(citationsContent.citations);
+		return contentBlocks.flatMap((contentBlock) => normalizeContentBlock(citations ? {
+			...contentBlock,
+			citations
+		} : contentBlock));
+	}
+	const guardContent = isRecord(block.guardContent) ? block.guardContent : void 0;
+	if (guardContent) {
+		const content = stringValue((isRecord(guardContent.text) ? guardContent.text : void 0)?.text) ?? stringValue(guardContent.text);
+		if (content) return [{
+			type: "text",
+			content
+		}];
+	}
+	try {
+		return [{
+			type: "text",
+			content: JSON.stringify(block)
+		}];
+	} catch {
+		return [{
+			type: "text",
+			content: "[unsupported content block]"
+		}];
+	}
+}
+function simplifyToolResult(content) {
+	const blocks = arrayValue(content);
+	if (!blocks) return content;
+	if (blocks.length === 1 && typeof blocks[0]?.text === "string") return blocks[0].text;
+	return blocks.flatMap((block) => normalizeContentBlock(block));
+}
+function s3Uri(value) {
+	const bucket = stringValue(value?.bucket);
+	const key = stringValue(value?.key);
+	return bucket && key ? `s3://${bucket}/${key}` : void 0;
+}
+var ConverseStreamState = class {
+	role = "assistant";
+	blocks = /* @__PURE__ */ new Map();
+	stopReason;
+	usage;
+	metadata = {};
+	responseModel;
+	error;
+	errorFields;
+	feed(event) {
+		if (!isRecord(event)) return;
+		const streamError = modeledStreamError(event);
+		if (streamError) {
+			this.error = streamError.error;
+			this.errorFields = streamError.fields;
+			return;
+		}
+		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) {
+			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;
+			const toolResult = isRecord(start?.toolResult) ? start?.toolResult : void 0;
+			const image = isRecord(start?.image) ? start?.image : void 0;
+			this.blocks.set(index, toolUse ? {
+				kind: "tool",
+				toolUseId: stringValue(toolUse.toolUseId),
+				name: stringValue(toolUse.name),
+				input: ""
+			} : toolResult ? {
+				kind: "content",
+				content: { toolResult: omitUndefined({
+					toolUseId: stringValue(toolResult.toolUseId),
+					status: stringValue(toolResult.status),
+					content: []
+				}) }
+			} : image ? {
+				kind: "content",
+				content: { image }
+			} : {
+				kind: "text",
+				text: ""
+			});
+		}
+		const deltaEvent = isRecord(event.contentBlockDelta) ? event.contentBlockDelta : void 0;
+		if (deltaEvent) {
+			const index = numberValue(deltaEvent.contentBlockIndex) ?? 0;
+			const delta = isRecord(deltaEvent.delta) ? deltaEvent.delta : {};
+			const block = this.blocks.get(index) ?? {
+				kind: "text",
+				text: ""
+			};
+			if (typeof delta.text === "string") {
+				block.kind = "text";
+				block.text = `${block.text ?? ""}${delta.text}`;
+			}
+			const toolUse = isRecord(delta.toolUse) ? delta.toolUse : void 0;
+			if (toolUse && typeof toolUse.input === "string") {
+				block.kind = "tool";
+				block.input = `${block.input ?? ""}${toolUse.input}`;
+			}
+			const reasoning = isRecord(delta.reasoningContent) ? delta.reasoningContent : void 0;
+			if (reasoning) {
+				block.kind = "reasoning";
+				block.text = `${block.text ?? ""}${stringValue(reasoning.text) ?? (reasoning.redactedContent ? "[redacted]" : "")}`;
+			}
+			const image = isRecord(delta.image) ? delta.image : void 0;
+			if (image) {
+				const content = isRecord(block.content) ? block.content : {};
+				const current = isRecord(content.image) ? content.image : {};
+				block.kind = "content";
+				block.content = { image: {
+					...current,
+					...image
+				} };
+			}
+			const toolResult = arrayValue(delta.toolResult);
+			if (toolResult) {
+				const content = isRecord(block.content) ? block.content : {};
+				const current = isRecord(content.toolResult) ? content.toolResult : {};
+				const currentContent = arrayValue(current.content) ?? [];
+				block.kind = "content";
+				block.content = { toolResult: {
+					...current,
+					content: [...currentContent, ...toolResult]
+				} };
+			}
+			if (isRecord(delta.citation)) block.citations = [...block.citations ?? [], delta.citation];
+			this.blocks.set(index, block);
+		}
+		const stop = isRecord(event.messageStop) ? event.messageStop : void 0;
+		if (stop) this.stopReason = stringValue(stop.stopReason) ?? this.stopReason;
+		const metadata = isRecord(event.metadata) ? event.metadata : void 0;
+		if (metadata) {
+			this.usage = usageFromConverse(metadata.usage) ?? this.usage;
+			const metrics = isRecord(metadata.metrics) ? metadata.metrics : void 0;
+			const trace = isRecord(metadata.trace) ? metadata.trace : void 0;
+			const promptRouter = isRecord(trace?.promptRouter) ? trace?.promptRouter : void 0;
+			const guardrail = isRecord(trace?.guardrail) ? trace?.guardrail : void 0;
+			this.responseModel = stringValue(promptRouter?.invokedModelId) ?? this.responseModel;
+			this.metadata = {
+				...this.metadata,
+				...omitUndefined({
+					server_latency_ms: numberValue(metrics?.latencyMs),
+					guardrail_action: stringValue(guardrail?.action),
+					guardrail_action_reason: stringValue(guardrail?.actionReason)
+				})
+			};
+		}
+	}
+	finish(partial) {
+		const parts = [...this.blocks.entries()].sort(([left], [right]) => left - right).map(([, block]) => blockToPart(block));
+		return mergeFields(omitUndefined({
+			output: parts.length > 0 ? [omitUndefined({
+				role: this.role,
+				parts,
+				finish_reason: partial ? void 0 : this.stopReason
+			})] : void 0,
+			finishReason: partial ? void 0 : this.stopReason,
+			usage: this.usage,
+			responseModel: this.responseModel,
+			metadata: Object.keys(this.metadata).length > 0 ? this.metadata : void 0,
+			error: this.error
+		}), this.errorFields);
+	}
+};
+function blockToPart(block) {
+	if (block.kind === "tool") return omitUndefined({
+		type: "tool_call",
+		id: block.toolUseId,
+		name: block.name,
+		arguments: parseJson(block.input) ?? block.input ?? ""
+	});
+	if (block.kind === "reasoning") return {
+		type: "reasoning",
+		content: block.text ?? ""
+	};
+	if (block.kind === "content" && block.content) return normalizeContentBlock(block.content)[0] ?? {};
+	return omitUndefined({
+		type: "text",
+		content: block.text ?? "",
+		citations: block.citations && block.citations.length > 0 ? block.citations : void 0
+	});
+}
+//#endregion
+//#region src/invoke-model.ts
+function isEmbeddingModel(modelId) {
+	const model = stringValue(modelId)?.toLowerCase() ?? "";
+	return model.includes("titan-embed") || model.includes("cohere.embed") || model.includes("-embedding");
+}
+function invokeModelSpanName(input) {
+	const model = stringValue(input.modelId) ?? "unknown";
+	return `${isEmbeddingModel(model) ? "embeddings" : "chat"} ${model}`;
+}
+function invokeModelRequestFields(input) {
+	const model = stringValue(input.modelId);
+	const body = parseBody(input.body, input.contentType);
+	return omitUndefined({
+		provider: PROVIDER,
+		model,
+		input: body,
+		outputType: isEmbeddingModel(model) ? "embedding" : void 0,
+		...nativeSamplingFields(model, body)
+	});
+}
+function invokeModelResponseFields(input, output) {
+	const model = stringValue(input.modelId);
+	const body = isRecord(output) ? parseBody(output.body, output.contentType) : void 0;
+	const metadata = isRecord(output) ? output.$metadata : void 0;
+	return mergeFields(awsMetadataFields(metadata), nativeResponseFields(model, body, metadata));
+}
+function parseBody(body, contentType) {
+	if (!(stringValue(contentType) ?? "application/json").includes("json")) return void 0;
+	return parseJson(body);
+}
+function nativeSamplingFields(model, body) {
+	if (!isRecord(body)) return {};
+	const lower = model?.toLowerCase() ?? "";
+	if (lower.includes("amazon.titan")) {
+		const cfg = isRecord(body.textGenerationConfig) ? body.textGenerationConfig : {};
+		return omitUndefined({
+			temperature: numberValue(cfg.temperature),
+			topP: numberValue(cfg.topP),
+			maxTokens: numberValue(cfg.maxTokenCount),
+			stopSequences: Array.isArray(cfg.stopSequences) ? cfg.stopSequences : void 0
+		});
+	}
+	if (lower.includes("amazon.nova")) {
+		const cfg = isRecord(body.inferenceConfig) ? body.inferenceConfig : {};
+		return omitUndefined({
+			temperature: numberValue(cfg.temperature),
+			topP: numberValue(cfg.topP) ?? numberValue(cfg.top_p),
+			topK: numberValue(cfg.topK),
+			maxTokens: numberValue(cfg.maxTokens) ?? numberValue(cfg.max_new_tokens),
+			stopSequences: Array.isArray(cfg.stopSequences) ? cfg.stopSequences : void 0
+		});
+	}
+	if (lower.includes("anthropic.claude")) return omitUndefined({
+		temperature: numberValue(body.temperature),
+		topP: numberValue(body.top_p),
+		topK: numberValue(body.top_k),
+		maxTokens: numberValue(body.max_tokens),
+		stopSequences: Array.isArray(body.stop_sequences) ? body.stop_sequences : void 0
+	});
+	if (lower.includes("meta.llama")) return omitUndefined({
+		temperature: numberValue(body.temperature),
+		topP: numberValue(body.top_p),
+		maxTokens: numberValue(body.max_gen_len)
+	});
+	return omitUndefined({
+		temperature: numberValue(body.temperature),
+		topP: numberValue(body.top_p) ?? numberValue(body.topP),
+		maxTokens: numberValue(body.max_tokens) ?? numberValue(body.maxTokens)
+	});
+}
+function nativeResponseFields(model, body, metadata) {
+	if (!isRecord(body)) return headerUsageFields(metadata);
+	const lower = model?.toLowerCase() ?? "";
+	if (isEmbeddingModel(model)) return withHeaderUsage({
+		output: body,
+		outputType: "embedding",
+		usage: omitUndefined({ inputTokens: numberValue(body.inputTextTokenCount) })
+	}, metadata);
+	if (lower.includes("amazon.titan")) {
+		const first = Array.isArray(body.results) && isRecord(body.results[0]) ? body.results[0] : {};
+		return omitUndefined({
+			output: body,
+			finishReason: stringValue(first.completionReason),
+			usage: omitUndefined({
+				inputTokens: numberValue(body.inputTextTokenCount),
+				outputTokens: numberValue(first.tokenCount)
+			})
+		});
+	}
+	if (lower.includes("amazon.nova")) {
+		const usage = isRecord(body.usage) ? body.usage : {};
+		return omitUndefined({
+			output: body,
+			finishReason: stringValue(body.stopReason),
+			usage: omitUndefined({
+				inputTokens: numberValue(usage.inputTokens),
+				outputTokens: numberValue(usage.outputTokens),
+				totalTokens: numberValue(usage.totalTokens)
+			})
+		});
+	}
+	if (lower.includes("anthropic.claude")) {
+		const usage = isRecord(body.usage) ? body.usage : {};
+		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)
+			})
+		}, metadata);
+	}
+	if (lower.includes("meta.llama")) return omitUndefined({
+		output: body,
+		finishReason: stringValue(body.stop_reason),
+		usage: omitUndefined({
+			inputTokens: numberValue(body.prompt_token_count),
+			outputTokens: numberValue(body.generation_token_count)
+		})
+	});
+	if (lower.includes("mistral")) return withHeaderUsage({
+		output: body,
+		finishReason: stringValue((Array.isArray(body.outputs) && isRecord(body.outputs[0]) ? body.outputs[0] : {}).stop_reason)
+	}, metadata);
+	if (lower.includes("cohere.command-r")) return withHeaderUsage({
+		output: body,
+		finishReason: stringValue(body.finish_reason)
+	}, metadata);
+	if (lower.includes("cohere.command")) return withHeaderUsage({
+		output: body,
+		finishReason: stringValue((Array.isArray(body.generations) && isRecord(body.generations[0]) ? body.generations[0] : {}).finish_reason)
+	}, metadata);
+	return withHeaderUsage({ output: body }, metadata);
+}
+function withHeaderUsage(fields, metadata) {
+	if (fields.usage && Object.keys(fields.usage).length > 0) return fields;
+	return mergeFields(fields, headerUsageFields(metadata));
+}
+function headerUsageFields(metadata) {
+	const headers = isRecord(metadata) ? isRecord(metadata.httpHeaders) ? metadata.httpHeaders : isRecord(metadata.HTTPHeaders) ? metadata.HTTPHeaders : void 0 : void 0;
+	const usage = omitUndefined({
+		inputTokens: headerNumber(headers?.["x-amzn-bedrock-input-token-count"]),
+		outputTokens: headerNumber(headers?.["x-amzn-bedrock-output-token-count"])
+	});
+	return { usage: Object.keys(usage).length > 0 ? usage : void 0 };
+}
+function headerNumber(value) {
+	if (typeof value === "string") {
+		const parsed = Number.parseInt(value, 10);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+	return numberValue(value);
+}
+var InvokeModelStreamState = class {
+	chunks = [];
+	text = "";
+	usage;
+	finishReason;
+	error;
+	errorFields;
+	feed(event) {
+		if (!isRecord(event)) return;
+		const streamError = modeledStreamError(event);
+		if (streamError) {
+			this.error = streamError.error;
+			this.errorFields = streamError.fields;
+			return;
+		}
+		const parsed = parseJson((isRecord(event.chunk) ? event.chunk : void 0)?.bytes);
+		if (parsed === void 0) return;
+		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;
+			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,
+				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
+			});
+		}
+	}
+	finish() {
+		return mergeFields(omitUndefined({
+			output: this.text ? [{
+				role: "assistant",
+				parts: [{
+					type: "text",
+					content: this.text
+				}],
+				finish_reason: this.finishReason
+			}] : this.chunks,
+			finishReason: this.finishReason,
+			usage: this.usage,
+			error: this.error
+		}), this.errorFields);
+	}
+};
+function textFromProviderChunk(value) {
+	if (!isRecord(value)) return "";
+	const delta = isRecord(value.delta) ? value.delta : void 0;
+	const contentBlockDelta = isRecord(value.contentBlockDelta) ? value.contentBlockDelta : isRecord(value.content_block_delta) ? value.content_block_delta : void 0;
+	const nestedDelta = isRecord(contentBlockDelta?.delta) ? contentBlockDelta?.delta : void 0;
+	const generation = Array.isArray(value.generations) && isRecord(value.generations[0]) ? value.generations[0] : void 0;
+	return stringValue(value.outputText) ?? stringValue(value.generation) ?? stringValue(value.completion) ?? stringValue(value.text) ?? stringValue(delta?.text) ?? stringValue(nestedDelta?.text) ?? (Array.isArray(value.outputs) && isRecord(value.outputs[0]) ? stringValue(value.outputs[0].text) : void 0) ?? stringValue(generation?.text) ?? "";
+}
+//#endregion
+//#region src/internal-handlers.ts
+const RUNTIME_HANDLERS = {
+	ConverseCommand: {
+		spanName: (input) => `chat ${stringValue(input.modelId) ?? "unknown"}`,
+		spanType: () => "generation",
+		requestFields: converseRequestFields,
+		onResult(result, span) {
+			endSpan(span, converseResponseFields(result));
+			return result;
+		}
+	},
+	ConverseStreamCommand: {
+		spanName: (input) => `chat ${stringValue(input.modelId) ?? "unknown"}`,
+		spanType: () => "generation",
+		requestFields: converseRequestFields,
+		onResult(result, span, t0) {
+			const response = result;
+			if (!response.stream) {
+				endSpan(span, awsMetadataFields(response.$metadata));
+				return result;
+			}
+			return {
+				...response,
+				stream: wrapAsyncIterable(response.stream, new ConverseStreamState(), span, t0, awsMetadataFields(response.$metadata))
+			};
+		}
+	},
+	InvokeModelCommand: {
+		spanName: invokeModelSpanName,
+		spanType: (input) => isEmbeddingModel(input.modelId) ? "embedding" : "generation",
+		requestFields: invokeModelRequestFields,
+		onResult(result, span, _t0, input) {
+			endSpan(span, invokeModelResponseFields(input, result));
+			return result;
+		}
+	},
+	InvokeModelWithResponseStreamCommand: {
+		spanName: invokeModelSpanName,
+		spanType: (input) => isEmbeddingModel(input.modelId) ? "embedding" : "generation",
+		requestFields: invokeModelRequestFields,
+		onResult(result, span, t0) {
+			const response = result;
+			if (!response.body) {
+				endSpan(span, awsMetadataFields(response.$metadata));
+				return result;
+			}
+			return {
+				...response,
+				body: wrapAsyncIterable(response.body, new InvokeModelStreamState(), span, t0, awsMetadataFields(response.$metadata))
+			};
+		}
+	},
+	ApplyGuardrailCommand: {
+		spanName: (input) => `apply_guardrail ${stringValue(input.guardrailIdentifier) ?? "unknown"}`,
+		spanType: () => "span",
+		requestFields: (input) => ({
+			provider: PROVIDER,
+			input: omitUndefined({
+				source: input.source,
+				content: input.content,
+				guardrailIdentifier: input.guardrailIdentifier,
+				guardrailVersion: input.guardrailVersion
+			})
+		}),
+		onResult(result, span) {
+			const response = result;
+			endSpan(span, mergeFields(awsMetadataFields(response.$metadata), {
+				output: omitUndefined({
+					outputs: response.outputs,
+					assessments: response.assessments
+				}),
+				metadata: omitUndefined({
+					guardrail_action: stringValue(response.action),
+					guardrail_action_reason: stringValue(response.actionReason)
+				})
+			}));
+			return result;
+		}
+	}
+};
+const AGENT_HANDLERS = {
+	InvokeAgentCommand: {
+		spanName: (input) => `invoke_agent ${stringValue(input.agentId) ?? "unknown"}`,
+		spanType: () => "agent",
+		requestFields: agentRequestFields,
+		onResult: streamAgentResult("completion")
+	},
+	InvokeInlineAgentCommand: {
+		spanName: (input) => `invoke_agent ${stringValue(input.agentName) ?? "inline-agent"}`,
+		spanType: () => "agent",
+		requestFields: inlineAgentRequestFields,
+		onResult: streamAgentResult("completion")
+	},
+	RetrieveCommand: {
+		spanName: (input) => `retrieve ${stringValue(input.knowledgeBaseId) ?? "unknown"}`,
+		spanType: () => "span",
+		requestFields: retrieveRequestFields,
+		onResult(result, span) {
+			endSpan(span, retrieveResponseFields(result));
+			return result;
+		}
+	},
+	RetrieveAndGenerateCommand: {
+		spanName: ragName,
+		spanType: () => "generation",
+		requestFields: ragRequestFields,
+		onResult(result, span) {
+			endSpan(span, ragResponseFields(result));
+			return result;
+		}
+	},
+	RetrieveAndGenerateStreamCommand: {
+		spanName: ragName,
+		spanType: () => "generation",
+		requestFields: ragRequestFields,
+		onResult(result, span, t0) {
+			const response = result;
+			const base = mergeFields(awsMetadataFields(response.$metadata), { metadata: omitUndefined({ bedrock_session_id: stringValue(response.sessionId) }) });
+			if (!response.stream) {
+				endSpan(span, base);
+				return result;
+			}
+			return {
+				...response,
+				stream: wrapAsyncIterable(response.stream, new RagStreamState(), span, t0, base)
+			};
+		}
+	},
+	InvokeFlowCommand: {
+		spanName: flowName,
+		spanType: () => "agent",
+		requestFields: flowRequestFields,
+		onResult(result, span, t0) {
+			const response = result;
+			if (!response.responseStream) {
+				endSpan(span, awsMetadataFields(response.$metadata));
+				return result;
+			}
+			return {
+				...response,
+				responseStream: wrapAsyncIterable(response.responseStream, new FlowStreamState(), span, t0, awsMetadataFields(response.$metadata))
+			};
+		}
+	}
+};
+function streamAgentResult(key) {
+	return (result, span, t0, _input, options) => {
+		const response = result;
+		const base = mergeFields(awsMetadataFields(response.$metadata), { metadata: omitUndefined({
+			bedrock_session_id: stringValue(response.sessionId),
+			bedrock_memory_id: stringValue(response.memoryId)
+		}) });
+		if (!response[key]) {
+			endSpan(span, base);
+			return result;
+		}
+		return {
+			...response,
+			[key]: wrapAsyncIterable(response[key], new AgentStreamState(options), span, t0, base)
+		};
+	};
+}
+//#endregion
+export { RUNTIME_HANDLERS as n, createInstrumentedSend as r, AGENT_HANDLERS as t };