@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/amazon-bedrock-B0nxT06F.mjs

@@ -0,0 +1,917 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { I as $flag, _ as parseStreamingJsonThrottled, g as parseStreamingJson } from "./src-lDmkSRbm.mjs";
+import { G as fetchWithRetry, I as BedrockApiError, U as EventStreamFrameError, l as finalize, r as ValidationError, v as AbortError } from "./error-yCSG0mGC.mjs";
+import { C as kStreamingPartialJson, S as kStreamingLastParseLen, a as normalizeSystemPrompts, h as clearStreamingPartialJson, k as toolWireSchema, m as transformMessages, o as normalizeToolCallId, s as resolveCacheRetention, w as renderDemotedThinking, y as kStreamingBlockIndex } from "./utils-Bw139LTz.mjs";
+import { i as resolveAwsBearerToken, n as resolveAwsCredentials, r as signRequest, s as resolveAwsAmbientRegion, t as invalidateAwsCredentialCache } from "./aws-credentials-ChG79ey-.mjs";
+import { o as mapEffortToAnthropicAdaptiveEffort, s as requireSupportedEffort, t as calculateCost } from "./models-D_XnT6ay.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-loUa0s1T.mjs";
+import { i as getStreamFirstEventTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-Baoyn3Hp.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/aws-eventstream.ts
+/**
+* `application/vnd.amazon.eventstream` decoder.
+*
+* Wire format (all integers big-endian):
+*
+*   [total length     u32]
+*   [headers length   u32]
+*   [prelude CRC32    u32]   <- CRC over the first 8 bytes
+*   [headers          headers_length]
+*   [payload          total_length - headers_length - 16]
+*   [message CRC32    u32]   <- CRC over the entire message minus the trailing 4 bytes
+*
+* Headers: a sequence of `[name_len u8][name utf8][value_type u8][value …]`.
+* We only need the typed values Bedrock emits (boolean true/false, byte, short,
+* integer, long, byte-array, string, timestamp, uuid). All are surfaced as
+* strings for ease of consumption — Bedrock only sets string-valued headers in
+* practice (`:event-type`, `:message-type`, `:content-type`, `:exception-type`).
+*/
+const PRELUDE_LEN = 8;
+const MESSAGE_CRC_LEN = 4;
+const HEADER_BLOCK_OFFSET = 12;
+const MIN_MESSAGE_LEN = 16;
+/** CRC32 (IEEE / zlib polynomial 0xEDB88320), matches `@aws-crypto/crc32`. */
+function crc32(bytes) {
+	return Bun.hash.crc32(bytes) >>> 0;
+}
+/**
+* Decode a single, fully buffered eventstream message. Throws if the framing is
+* malformed or either CRC mismatches. Used by both `decodeEventStream` (the
+* streaming entry point) and the unit tests, which exercise it with hand-built
+* frames.
+*/
+function decodeMessage(frame) {
+	if (frame.length < MIN_MESSAGE_LEN) throw new EventStreamFrameError("frame too short");
+	const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+	const total = view.getUint32(0, false);
+	if (total !== frame.length) throw new EventStreamFrameError(`framed length ${total} != buffer ${frame.length}`);
+	const headersLen = view.getUint32(4, false);
+	const preludeCrc = view.getUint32(8, false);
+	if (crc32(frame.subarray(0, PRELUDE_LEN)) !== preludeCrc) throw new EventStreamFrameError("prelude CRC mismatch");
+	const msgCrc = view.getUint32(total - MESSAGE_CRC_LEN, false);
+	if (crc32(frame.subarray(0, total - MESSAGE_CRC_LEN)) !== msgCrc) throw new EventStreamFrameError("message CRC mismatch");
+	const headersBytes = frame.subarray(HEADER_BLOCK_OFFSET, HEADER_BLOCK_OFFSET + headersLen);
+	const payload = frame.subarray(HEADER_BLOCK_OFFSET + headersLen, total - MESSAGE_CRC_LEN);
+	return {
+		headers: parseHeaders(headersBytes),
+		payload
+	};
+}
+function parseHeaders(buf) {
+	const out = {};
+	const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+	const decoder = new TextDecoder();
+	let p = 0;
+	while (p < buf.length) {
+		const nameLen = view.getUint8(p);
+		p += 1;
+		const name = decoder.decode(buf.subarray(p, p + nameLen));
+		p += nameLen;
+		const type = view.getUint8(p);
+		p += 1;
+		switch (type) {
+			case 0:
+				out[name] = "true";
+				break;
+			case 1:
+				out[name] = "false";
+				break;
+			case 2:
+				out[name] = String(view.getInt8(p));
+				p += 1;
+				break;
+			case 3:
+				out[name] = String(view.getInt16(p, false));
+				p += 2;
+				break;
+			case 4:
+				out[name] = String(view.getInt32(p, false));
+				p += 4;
+				break;
+			case 5:
+				out[name] = bigIntFromBytes(buf.subarray(p, p + 8)).toString();
+				p += 8;
+				break;
+			case 6: {
+				const len = view.getUint16(p, false);
+				p += 2;
+				out[name] = Buffer.from(buf.buffer, buf.byteOffset + p, len).toString("base64");
+				p += len;
+				break;
+			}
+			case 7: {
+				const len = view.getUint16(p, false);
+				p += 2;
+				out[name] = decoder.decode(buf.subarray(p, p + len));
+				p += len;
+				break;
+			}
+			case 8:
+				out[name] = new Date(Number(bigIntFromBytes(buf.subarray(p, p + 8)))).toISOString();
+				p += 8;
+				break;
+			case 9: {
+				const u = buf.subarray(p, p + 16);
+				const hex = [];
+				for (let i = 0; i < 16; i++) hex.push(u[i].toString(16).padStart(2, "0"));
+				out[name] = `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+				p += 16;
+				break;
+			}
+			default: throw new EventStreamFrameError(`unknown header value type ${type}`);
+		}
+	}
+	return out;
+}
+function bigIntFromBytes(b) {
+	let v = 0n;
+	for (let i = 0; i < b.length; i++) v = v << 8n | BigInt(b[i]);
+	if (b.length === 8 && b[0] & 128) v -= 1n << 64n;
+	return v;
+}
+/**
+* Async generator that consumes a `ReadableStream<Uint8Array>` (e.g. a fetch
+* response body) and yields fully-framed messages. Handles arbitrary chunk
+* boundaries: messages may span multiple chunks, and a single chunk may carry
+* many messages.
+*/
+async function* decodeEventStream(source) {
+	const reader = source.getReader();
+	let buf = /* @__PURE__ */ new Uint8Array(0);
+	let completed = false;
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (value && value.length > 0) buf = buf.length === 0 ? value : Buffer.concat([buf, value]);
+			let offset = 0;
+			while (buf.length - offset >= 4) {
+				const total = new DataView(buf.buffer, buf.byteOffset + offset, buf.length - offset).getUint32(0, false);
+				if (total < MIN_MESSAGE_LEN) throw new EventStreamFrameError(`total length ${total} below minimum`);
+				if (buf.length - offset < total) break;
+				yield decodeMessage(buf.subarray(offset, offset + total));
+				offset += total;
+			}
+			if (offset > 0) buf = buf.slice(offset);
+			if (done) break;
+		}
+		if (buf.length > 0) throw new EventStreamFrameError("truncated message at end of stream");
+		completed = true;
+	} finally {
+		if (!completed) await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/amazon-bedrock.ts
+/**
+* Headers SigV4 generates for itself. A caller cannot be allowed to supply these:
+* `signRequest` would sign the caller's value but return its own, so the signature
+* would not match what goes on the wire.
+*/
+const SIGNER_OWNED_HEADERS = /* @__PURE__ */ new Set([
+	"host",
+	"x-amz-date",
+	"x-amz-content-sha256",
+	"x-amz-security-token"
+]);
+/** Headers the Bedrock request sets itself; a caller copy in any casing duplicates them. */
+const BEDROCK_RESERVED_HEADERS = /* @__PURE__ */ new Set([
+	"content-type",
+	"accept",
+	"authorization",
+	"content-length"
+]);
+function resolveBearerToken(options) {
+	return resolveAwsBearerToken(options.apiKey, options.bearerToken);
+}
+function inferRegionFromBedrockArn(modelId) {
+	const parts = modelId.split(":", 6);
+	if (parts[0] !== "arn" || parts[2] !== "bedrock") return void 0;
+	return parts[3] || void 0;
+}
+/**
+* Default AWS region for each Bedrock cross-region inference-profile geo prefix.
+* A geo-prefixed profile (e.g. `eu.anthropic.claude-…`) is only servable from
+* regions in its own geo, so routing one to `us-east-1` yields HTTP 400 "The
+* provided model identifier is invalid." `global.` profiles are anchored in the
+* us regions and intentionally absent here (they resolve fine via `us-east-1`).
+*/
+const INFERENCE_PROFILE_GEO_DEFAULT_REGION = {
+	us: "us-east-1",
+	"us-gov": "us-gov-west-1",
+	eu: "eu-west-1",
+	apac: "ap-southeast-1",
+	au: "ap-southeast-2",
+	jp: "ap-northeast-1"
+};
+/** Geo prefix of a cross-region inference-profile id, e.g. `eu.anthropic.…` → `eu`. */
+function inferenceProfileGeo(modelId) {
+	const dot = modelId.indexOf(".");
+	if (dot <= 0) return void 0;
+	const prefix = modelId.slice(0, dot);
+	return prefix in INFERENCE_PROFILE_GEO_DEFAULT_REGION ? prefix : void 0;
+}
+/**
+* Whether a concrete AWS region can serve a given inference-profile geo. The
+* `ap-` regions overlap across `apac`/`au`/`jp` profiles, so the Australia and
+* Japan geos pin their specific source regions rather than matching all `ap-*`.
+*/
+function regionServesGeo(region, geo) {
+	switch (geo) {
+		case "us-gov": return region.startsWith("us-gov-");
+		case "us": return region.startsWith("us-") && !region.startsWith("us-gov-");
+		case "eu": return region.startsWith("eu-");
+		case "apac": return region.startsWith("ap-");
+		case "au": return region === "ap-southeast-2" || region === "ap-southeast-4";
+		case "jp": return region === "ap-northeast-1" || region === "ap-northeast-3";
+		default: return false;
+	}
+}
+/**
+* Resolve the Bedrock runtime region for a request. An explicit per-request
+* region and an ARN-embedded region win outright. Otherwise, for a geo-prefixed
+* cross-region inference profile (`us.`/`eu.`/`apac.`/`au.`/`jp.`/`us-gov.`), an
+* ambient region (`AWS_REGION` / `AWS_DEFAULT_REGION`) is honored only when it
+* can serve the profile's geo; a mismatched or absent ambient region is
+* corrected to the geo default so an `eu.`/`apac.` profile never POSTs to a `us`
+* endpoint (and vice versa). `global.` profiles have no geo entry, so the
+* ambient region (or `us-east-1`) is used unchanged.
+*/
+function resolveBedrockRegion(modelId, options) {
+	const explicit = options.region || inferRegionFromBedrockArn(modelId);
+	if (explicit) return explicit;
+	const ambient = resolveAwsAmbientRegion(options.profile);
+	const geo = inferenceProfileGeo(modelId);
+	if (geo) {
+		if (ambient && regionServesGeo(ambient, geo)) return ambient;
+		return INFERENCE_PROFILE_GEO_DEFAULT_REGION[geo];
+	}
+	return ambient || "us-east-1";
+}
+/**
+* Bedrock validates that requests carrying any `toolUse`/`toolResult` history
+* include a `toolConfig`. For no-tool ephemeral turns (`/btw`, IRC auto-replies)
+* we have nothing real to send, so we inject this placeholder. Its presence is
+* tracked by a per-request flag — never the wire name — so callers who happen
+* to register a real tool literally called `__no_tools__` are not affected.
+*/
+const NO_TOOLS_SENTINEL_NAME = "__no_tools__";
+const NO_TOOLS_SENTINEL = { toolSpec: {
+	name: NO_TOOLS_SENTINEL_NAME,
+	description: "Placeholder required by Bedrock validation. Do not call; answer with text.",
+	inputSchema: { json: {
+		type: "object",
+		properties: {}
+	} }
+} };
+const streamBedrock = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const output = {
+			role: "assistant",
+			content: [],
+			api: "bedrock-converse-stream",
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			},
+			stopReason: "stop",
+			timestamp: Date.now()
+		};
+		const blocks = output.content;
+		let rawRequestDump;
+		const region = resolveBedrockRegion(model.id, options);
+		try {
+			const promptCachePolicy = resolvePromptCachePolicy(model, resolveCacheRetention(options.cacheRetention));
+			const convertedMessages = convertMessages(context, model, promptCachePolicy);
+			const toolPlan = planToolConfig(context.tools, options.toolChoice, convertedMessages);
+			const toolConfig = toolPlan.toolConfig;
+			const sentinelInjected = toolPlan.sentinelInjected;
+			let additionalModelRequestFields = buildAdditionalModelRequestFields(model, options);
+			if (toolConfig?.toolChoice && additionalModelRequestFields) {
+				const tc = toolConfig.toolChoice;
+				if (tc.any || tc.tool) additionalModelRequestFields = void 0;
+			}
+			const commandInput = {
+				messages: convertedMessages,
+				system: buildSystemPrompt(context.systemPrompt, promptCachePolicy),
+				inferenceConfig: {
+					maxTokens: options.maxTokens,
+					temperature: options.temperature,
+					topP: options.topP
+				},
+				toolConfig,
+				additionalModelRequestFields
+			};
+			options?.onPayload?.(commandInput, model);
+			const host = `bedrock-runtime.${region}.amazonaws.com`;
+			const url = `https://${host}/model/${encodeURIComponent(model.id)}/converse-stream`;
+			const urlPath = `/model/${encodeURIComponent(model.id)}/converse-stream`;
+			rawRequestDump = {
+				provider: model.provider,
+				api: output.api,
+				model: model.id,
+				method: "POST",
+				url,
+				body: commandInput
+			};
+			const bodyText = JSON.stringify(commandInput);
+			const body = new TextEncoder().encode(bodyText);
+			const callerHeaders = {};
+			for (const [name, value] of Object.entries(options?.headers ?? {})) {
+				const field = name.toLowerCase();
+				if (SIGNER_OWNED_HEADERS.has(field) || BEDROCK_RESERVED_HEADERS.has(field)) continue;
+				callerHeaders[field] = value;
+			}
+			const baseHeaders = {
+				...callerHeaders,
+				"content-type": "application/json",
+				accept: "application/vnd.amazon.eventstream"
+			};
+			const bearerToken = resolveBearerToken(options);
+			let requestHeaders;
+			if (bearerToken) requestHeaders = {
+				...baseHeaders,
+				Authorization: `Bearer ${bearerToken}`
+			};
+			else {
+				let credentials;
+				if ($flag("AWS_BEDROCK_SKIP_AUTH")) credentials = {
+					accessKeyId: "dummy-access-key",
+					secretAccessKey: "dummy-secret-key"
+				};
+				else credentials = await resolveAwsCredentials({
+					profile: options.profile,
+					region,
+					signal: options.signal,
+					fetch: options.fetch
+				});
+				const signed = await signRequest({
+					method: "POST",
+					host,
+					path: urlPath,
+					body,
+					region,
+					service: "bedrock",
+					credentials,
+					headers: baseHeaders
+				});
+				requestHeaders = {
+					...baseHeaders,
+					...signed
+				};
+			}
+			const firstEventTimeoutMs = options.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs();
+			const watchdog = armPreResponseTimeout(options.signal, firstEventTimeoutMs);
+			let response;
+			try {
+				response = await fetchWithRetry(url, {
+					method: "POST",
+					headers: requestHeaders,
+					body,
+					signal: watchdog.signal,
+					fetch: options.fetch,
+					timeout: false
+				});
+			} finally {
+				watchdog.clear();
+			}
+			if (!response.ok) {
+				if (!bearerToken && (response.status === 401 || response.status === 403)) invalidateAwsCredentialCache({
+					profile: options.profile,
+					region
+				});
+				const errBody = await response.text().catch(() => "");
+				throw new BedrockApiError(`Bedrock HTTP ${response.status}: ${errBody.slice(0, 1e3)}`, response.status, { headers: response.headers });
+			}
+			if (!response.body) throw new BedrockApiError("Bedrock response has no body", response.status);
+			for await (const message of decodeEventStream(response.body)) {
+				const messageType = message.headers[":message-type"];
+				const eventType = message.headers[":event-type"];
+				if (messageType === "exception") {
+					const exceptionType = message.headers[":exception-type"] || "Exception";
+					const text = `${exceptionType}: ${safeParsePayload(message.payload)?.message || new TextDecoder().decode(message.payload)}`;
+					throw new BedrockApiError(text, 400, { code: exceptionType });
+				}
+				if (messageType === "error") {
+					const code = message.headers[":error-code"] || "UnknownError";
+					const errorMessage = message.headers[":error-message"] || new TextDecoder().decode(message.payload);
+					throw new BedrockApiError(`${code}: ${errorMessage}`, 400, { code });
+				}
+				if (messageType !== "event") continue;
+				const payload = safeParsePayload(message.payload);
+				if (!payload) continue;
+				switch (eventType) {
+					case "messageStart":
+						if (payload.role !== "assistant") throw new BedrockApiError("Unexpected assistant message start but got user message start instead", 0);
+						stream.push({
+							type: "start",
+							partial: output
+						});
+						break;
+					case "contentBlockStart":
+						if (!firstTokenTime) firstTokenTime = performance.now();
+						handleContentBlockStart(payload, blocks, output, stream, sentinelInjected);
+						break;
+					case "contentBlockDelta":
+						if (!firstTokenTime) firstTokenTime = performance.now();
+						handleContentBlockDelta(payload, blocks, output, stream);
+						break;
+					case "contentBlockStop":
+						handleContentBlockStop(payload, blocks, output, stream);
+						break;
+					case "messageStop": {
+						const ev = payload;
+						output.stopReason = sentinelInjected && ev.stopReason === "tool_use" ? "stop" : mapStopReason(ev.stopReason);
+						if (output.stopReason === "error") output.errorMessage = `Generation failed with stop reason: ${ev.stopReason ?? "unknown"}`;
+						break;
+					}
+					case "metadata": handleMetadata(payload, model, output);
+				}
+			}
+			if (options.signal?.aborted) throw new AbortError();
+			if (output.stopReason === "error" || output.stopReason === "aborted") throw new BedrockApiError(output.errorMessage ?? "An unknown error occurred", 0);
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) if (block.type === "toolCall") clearStreamingPartialJson(block);
+			let baseMessage;
+			try {
+				baseMessage = error instanceof Error ? error.message : JSON.stringify(error) ?? String(error);
+			} catch {
+				baseMessage = String(error);
+			}
+			let diagnostics = "";
+			if (baseMessage.includes("signature") || baseMessage.includes("thinking")) {
+				const thinkingBlocks = context.messages.filter((m) => m.role === "assistant").flatMap((m, mi) => m.content.filter((b) => b.type === "thinking").map((b, bi) => ({
+					msg: mi,
+					block: bi,
+					stop: m.stopReason,
+					sigLen: b.thinkingSignature?.length ?? -1,
+					thinkLen: b.thinking.length
+				})));
+				if (thinkingBlocks.length > 0) diagnostics = `\n[thinking-diag] ${JSON.stringify(thinkingBlocks)}`;
+			}
+			const result = await finalize(error, {
+				api: model.api,
+				signal: options.signal,
+				rawRequestDump
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message + diagnostics;
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+function safeParsePayload(payload) {
+	if (payload.length === 0) return {};
+	try {
+		return JSON.parse(new TextDecoder().decode(payload));
+	} catch {
+		return;
+	}
+}
+function handleContentBlockStart(event, blocks, output, stream, sentinelInjected) {
+	const index = event.contentBlockIndex;
+	const start = event.start;
+	if (sentinelInjected && start?.toolUse?.name === NO_TOOLS_SENTINEL_NAME) return;
+	if (start?.toolUse) {
+		const block = {
+			type: "toolCall",
+			id: normalizeToolCallId(start.toolUse.toolUseId || ""),
+			name: start.toolUse.name || "",
+			arguments: {},
+			[kStreamingPartialJson]: "",
+			[kStreamingBlockIndex]: index
+		};
+		output.content.push(block);
+		stream.push({
+			type: "toolcall_start",
+			contentIndex: blocks.length - 1,
+			partial: output
+		});
+	}
+}
+function handleContentBlockDelta(event, blocks, output, stream) {
+	const contentBlockIndex = event.contentBlockIndex;
+	const delta = event.delta;
+	let index = blocks.findIndex((b) => b[kStreamingBlockIndex] === contentBlockIndex);
+	let block = blocks[index];
+	if (delta?.text !== void 0) {
+		if (!block) {
+			const newBlock = {
+				type: "text",
+				text: "",
+				[kStreamingBlockIndex]: contentBlockIndex
+			};
+			output.content.push(newBlock);
+			index = blocks.length - 1;
+			block = blocks[index];
+			stream.push({
+				type: "text_start",
+				contentIndex: index,
+				partial: output
+			});
+		}
+		if (block.type === "text") {
+			block.text += delta.text;
+			stream.push({
+				type: "text_delta",
+				contentIndex: index,
+				delta: delta.text,
+				partial: output
+			});
+		}
+	} else if (delta?.toolUse && block?.type === "toolCall") {
+		block[kStreamingPartialJson] = (block[kStreamingPartialJson] || "") + (delta.toolUse.input || "");
+		const throttled = parseStreamingJsonThrottled(block[kStreamingPartialJson], block[kStreamingLastParseLen] ?? 0);
+		if (throttled) {
+			block.arguments = throttled.value;
+			block[kStreamingLastParseLen] = throttled.parsedLen;
+		}
+		stream.push({
+			type: "toolcall_delta",
+			contentIndex: index,
+			delta: delta.toolUse.input || "",
+			partial: output
+		});
+	} else if (delta?.reasoningContent) {
+		let thinkingBlock = block;
+		let thinkingIndex = index;
+		if (!thinkingBlock) {
+			const newBlock = {
+				type: "thinking",
+				thinking: "",
+				thinkingSignature: "",
+				[kStreamingBlockIndex]: contentBlockIndex
+			};
+			output.content.push(newBlock);
+			thinkingIndex = blocks.length - 1;
+			thinkingBlock = blocks[thinkingIndex];
+			stream.push({
+				type: "thinking_start",
+				contentIndex: thinkingIndex,
+				partial: output
+			});
+		}
+		if (thinkingBlock?.type === "thinking") {
+			if (delta.reasoningContent.text) {
+				thinkingBlock.thinking += delta.reasoningContent.text;
+				stream.push({
+					type: "thinking_delta",
+					contentIndex: thinkingIndex,
+					delta: delta.reasoningContent.text,
+					partial: output
+				});
+			}
+			if (delta.reasoningContent.signature) thinkingBlock.thinkingSignature = (thinkingBlock.thinkingSignature || "") + delta.reasoningContent.signature;
+		}
+	}
+}
+function handleMetadata(event, model, output) {
+	if (event.usage) {
+		output.usage.input = event.usage.inputTokens || 0;
+		output.usage.output = event.usage.outputTokens || 0;
+		output.usage.cacheRead = event.usage.cacheReadInputTokens || 0;
+		output.usage.cacheWrite = event.usage.cacheWriteInputTokens || 0;
+		output.usage.totalTokens = event.usage.totalTokens || output.usage.input + output.usage.output;
+		calculateCost(model, output.usage);
+	}
+}
+function handleContentBlockStop(event, blocks, output, stream) {
+	const index = blocks.findIndex((b) => b[kStreamingBlockIndex] === event.contentBlockIndex);
+	const block = blocks[index];
+	if (!block) return;
+	switch (block.type) {
+		case "text":
+			stream.push({
+				type: "text_end",
+				contentIndex: index,
+				content: block.text,
+				partial: output
+			});
+			break;
+		case "thinking":
+			stream.push({
+				type: "thinking_end",
+				contentIndex: index,
+				content: block.thinking,
+				partial: output
+			});
+			break;
+		case "toolCall":
+			block.arguments = parseStreamingJson(block[kStreamingPartialJson]);
+			clearStreamingPartialJson(block);
+			stream.push({
+				type: "toolcall_end",
+				contentIndex: index,
+				toolCall: block,
+				partial: output
+			});
+	}
+}
+/**
+* Resolve Bedrock's explicit-cache request policy from the catalog's
+* materialized provider contract. Bedrock enforces each model's minimum
+* prefix-token requirement, so this boundary intentionally does not locally
+* count tokens. The emitter prioritizes the final user boundary, then the
+* system boundary, without exceeding the configured checkpoint maximum.
+*
+* `AWS_BEDROCK_FORCE_CACHE` remains an escape hatch for opaque application
+* inference profiles, defaulting those otherwise-unknown models to the
+* existing two-checkpoint layout without inventing 1h retention.
+*/
+function resolvePromptCachePolicy(model, cacheRetention) {
+	if (cacheRetention === "none" || model.compat.promptCacheMode === "automatic") return { remainingCheckpoints: 0 };
+	const forced = $flag("AWS_BEDROCK_FORCE_CACHE");
+	const explicit = model.compat.promptCacheMode === "explicit";
+	if (!explicit && !forced) return { remainingCheckpoints: 0 };
+	const configuredMaximum = explicit ? model.compat.promptCacheMaximumCheckpoints : 2;
+	if (configuredMaximum <= 0) return { remainingCheckpoints: 0 };
+	return {
+		remainingCheckpoints: Math.min(configuredMaximum, 2),
+		...cacheRetention === "long" && model.compat.supportsLongPromptCacheRetention ? { ttl: "1h" } : {}
+	};
+}
+function takeCachePoint(policy) {
+	if (policy.remainingCheckpoints <= 0) return void 0;
+	policy.remainingCheckpoints--;
+	return { cachePoint: {
+		type: "default",
+		...policy.ttl ? { ttl: policy.ttl } : {}
+	} };
+}
+/**
+* Check if the model supports thinking signatures in reasoningContent.
+* Only Anthropic Claude models support the signature field.
+* Other models (Nova, Titan, Mistral, Llama, etc.) reject it with:
+* "This model doesn't support the reasoningContent.reasoningText.signature field"
+*/
+function supportsThinkingSignature(model) {
+	const id = model.id.toLowerCase();
+	return id.includes("anthropic.claude") || id.includes("anthropic/claude");
+}
+function buildSystemPrompt(systemPrompt, promptCachePolicy) {
+	const prompts = normalizeSystemPrompts(systemPrompt);
+	if (prompts.length === 0) return void 0;
+	const blocks = prompts.map((prompt) => ({ text: prompt }));
+	const cachePoint = takeCachePoint(promptCachePolicy);
+	if (cachePoint) blocks.push(cachePoint);
+	return blocks;
+}
+function convertMessages(context, model, promptCachePolicy) {
+	const result = [];
+	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+	for (let i = 0; i < transformedMessages.length; i++) {
+		const m = transformedMessages[i];
+		switch (m.role) {
+			case "developer":
+			case "user":
+				if (typeof m.content === "string") {
+					if (!m.content || m.content.trim() === "") continue;
+					result.push({
+						role: "user",
+						content: [{ text: m.content.toWellFormed() }]
+					});
+				} else {
+					const contentBlocks = [];
+					for (const c of m.content) switch (c.type) {
+						case "text": {
+							const text = c.text.toWellFormed();
+							if (text.trim().length === 0) continue;
+							contentBlocks.push({ text });
+							break;
+						}
+						case "image":
+							contentBlocks.push({ image: createImageBlock(c.mimeType, c.data) });
+							break;
+						default: throw new ValidationError("Unknown user content type");
+					}
+					if (contentBlocks.length === 0) continue;
+					result.push({
+						role: "user",
+						content: contentBlocks
+					});
+				}
+				break;
+			case "assistant": {
+				if (m.content.length === 0) continue;
+				const contentBlocks = [];
+				for (const c of m.content) switch (c.type) {
+					case "text":
+						if (c.text.trim().length === 0) continue;
+						contentBlocks.push({ text: c.text.toWellFormed() });
+						break;
+					case "toolCall":
+						contentBlocks.push({ toolUse: {
+							toolUseId: normalizeToolCallId(c.id),
+							name: c.name,
+							input: c.arguments
+						} });
+						break;
+					case "thinking":
+						if (c.thinking.trim().length === 0) continue;
+						if (c.thinkingSignature) contentBlocks.push({ reasoningContent: { reasoningText: {
+							text: c.thinking.toWellFormed(),
+							signature: c.thinkingSignature
+						} } });
+						else if (!supportsThinkingSignature(model)) contentBlocks.push({ reasoningContent: { reasoningText: { text: c.thinking.toWellFormed() } } });
+						else contentBlocks.push({ text: renderDemotedThinking(model.id, c.thinking) });
+						break;
+					default: throw new ValidationError("Unknown assistant content type");
+				}
+				if (contentBlocks.length === 0) continue;
+				result.push({
+					role: "assistant",
+					content: contentBlocks
+				});
+				break;
+			}
+			case "toolResult": {
+				const toolResults = [];
+				toolResults.push({ toolResult: {
+					toolUseId: normalizeToolCallId(m.toolCallId),
+					content: m.content.map((c) => c.type === "image" ? { image: createImageBlock(c.mimeType, c.data) } : { text: c.text.toWellFormed() }),
+					status: m.isError ? "error" : "success"
+				} });
+				let j = i + 1;
+				while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
+					const nextMsg = transformedMessages[j];
+					toolResults.push({ toolResult: {
+						toolUseId: normalizeToolCallId(nextMsg.toolCallId),
+						content: nextMsg.content.map((c) => c.type === "image" ? { image: createImageBlock(c.mimeType, c.data) } : { text: c.text.toWellFormed() }),
+						status: nextMsg.isError ? "error" : "success"
+					} });
+					j++;
+				}
+				i = j - 1;
+				result.push({
+					role: "user",
+					content: toolResults
+				});
+				break;
+			}
+			default: throw new ValidationError("Unknown message role");
+		}
+	}
+	if (result.length > 0) {
+		const lastMessage = result[result.length - 1];
+		if (lastMessage.role === "user" && lastMessage.content) {
+			const cachePoint = takeCachePoint(promptCachePolicy);
+			if (cachePoint) lastMessage.content.push(cachePoint);
+		}
+	}
+	return result;
+}
+function messagesHaveToolBlocks(messages) {
+	for (const message of messages) for (const block of message.content) if ("toolUse" in block || "toolResult" in block) return true;
+	return false;
+}
+function convertToolSpec(tool) {
+	return { toolSpec: {
+		name: tool.name,
+		description: tool.description || "",
+		inputSchema: { json: toolWireSchema(tool) }
+	} };
+}
+function planToolConfig(tools, toolChoice, messages) {
+	const activeTools = tools ?? [];
+	const hasTools = activeTools.length > 0;
+	const historyHasToolBlocks = messagesHaveToolBlocks(messages);
+	if (toolChoice === "none") {
+		if (!historyHasToolBlocks) return {
+			toolConfig: void 0,
+			sentinelInjected: false
+		};
+		if (!hasTools) return {
+			toolConfig: {
+				tools: [NO_TOOLS_SENTINEL],
+				toolChoice: { auto: {} }
+			},
+			sentinelInjected: true
+		};
+		return {
+			toolConfig: { tools: activeTools.map(convertToolSpec) },
+			sentinelInjected: false
+		};
+	}
+	if (!hasTools) return {
+		toolConfig: void 0,
+		sentinelInjected: false
+	};
+	const bedrockTools = activeTools.map(convertToolSpec);
+	let bedrockToolChoice;
+	switch (toolChoice) {
+		case "auto":
+			bedrockToolChoice = { auto: {} };
+			break;
+		case "any":
+			bedrockToolChoice = { any: {} };
+			break;
+		default: if (toolChoice?.type === "tool") bedrockToolChoice = { tool: { name: toolChoice.name } };
+	}
+	return {
+		toolConfig: {
+			tools: bedrockTools,
+			toolChoice: bedrockToolChoice
+		},
+		sentinelInjected: false
+	};
+}
+function mapStopReason(reason) {
+	switch (reason) {
+		case "end_turn":
+		case "stop_sequence": return "stop";
+		case "max_tokens":
+		case "model_context_window_exceeded": return "length";
+		case "tool_use": return "toolUse";
+		default: return "error";
+	}
+}
+function buildAdditionalModelRequestFields(model, options) {
+	const reasoning = options.reasoning;
+	if (!reasoning || !model.reasoning) return void 0;
+	if (model.thinking?.mode === "anthropic-adaptive") {
+		const effort = mapEffortToAnthropicAdaptiveEffort(model, reasoning);
+		const adaptive = { type: "adaptive" };
+		if (model.thinking?.supportsDisplay) adaptive.display = options.thinkingDisplay ?? "summarized";
+		return {
+			thinking: adaptive,
+			output_config: { effort }
+		};
+	}
+	const level = requireSupportedEffort(model, reasoning);
+	const result = { thinking: {
+		type: "enabled",
+		budget_tokens: options.thinkingBudgets?.[level] ?? {
+			minimal: 1024,
+			low: 2048,
+			medium: 8192,
+			high: 16384,
+			xhigh: 32768,
+			max: 32768
+		}[level],
+		display: options.thinkingDisplay ?? "summarized"
+	} };
+	if (options.interleavedThinking) result.anthropic_beta = ["interleaved-thinking-2025-05-14"];
+	return result;
+}
+/**
+* Bedrock's wire format expects the image as `{ source: { bytes: <base64-string> }, format }`.
+* The caller already passes base64-encoded data, so no decode/re-encode round-trip is needed.
+*/
+function createImageBlock(mimeType, data) {
+	let format;
+	switch (mimeType) {
+		case "image/jpeg":
+		case "image/jpg":
+			format = "jpeg";
+			break;
+		case "image/png":
+			format = "png";
+			break;
+		case "image/gif":
+			format = "gif";
+			break;
+		case "image/webp":
+			format = "webp";
+			break;
+		default: throw new ValidationError(`Unknown image type: ${mimeType}`);
+	}
+	return {
+		source: { bytes: data },
+		format
+	};
+}
+//#endregion
+export { streamBedrock };