@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/amazon-bedrock-Dx0rr9dY.mjs

@@ -1,996 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { B as USER_AGENT, C as warn, F as $flag, _ as parseStreamingJson, v as parseStreamingJsonThrottled } from "./src-AELUUb5U.mjs";
-import { G as fetchWithRetry, I as BedrockApiError, U as EventStreamFrameError, _ as AbortError, c as finalize, r as ValidationError } from "./error-O63pC8zg.mjs";
-import { A as toolWireSchema, C as kStreamingLastParseLen, T as renderDemotedThinking, b as kStreamingBlockIndex, c as resolveCacheRetention, g as clearStreamingPartialJson, h as transformMessages, o as normalizeSystemPrompts, s as normalizeToolCallId, w as kStreamingPartialJson } from "./utils-cZX3f_Ls.mjs";
-import { n as isRecord } from "./type-guards-CttAANEx.mjs";
-import { a as mapEffortToAnthropicAdaptiveEffort, c as invalidateAwsCredentialCache, d as resolveAwsBearerToken, l as resolveAwsCredentials, m as resolveAwsAmbientRegion, o as requireSupportedEffort, r as parseAnthropicInputTransformations, t as THINKING_BINDING_CONTROLS_BETA, u as signRequest } from "./anthropic-wire-lbGAFzYb.mjs";
-import { t as calculateCost } from "./models-DnXMYGcJ.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-BKEtb45Y.mjs";
-import { i as getStreamFirstEventTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-D0ZXEcUq.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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@18.1.17/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 model 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. If the ambient region is
-* absent or mismatched, a same-geo guardrail ARN region is used when available;
-* otherwise the geo default is used. `global.` profiles have no geo entry, so
-* the ambient region (or, when absent, a guardrail ARN's 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 guardrailRegion = inferRegionFromBedrockArn(options.guardrailIdentifier ?? "");
-	const geo = inferenceProfileGeo(modelId);
-	if (geo) {
-		if (ambient && regionServesGeo(ambient, geo)) return ambient;
-		if (guardrailRegion && regionServesGeo(guardrailRegion, geo)) return guardrailRegion;
-		return INFERENCE_PROFILE_GEO_DEFAULT_REGION[geo];
-	}
-	return ambient || guardrailRegion || "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 REQUEST_METADATA_PATTERN = /^[a-zA-Z0-9\s:_@$#=/+,\-.]*$/;
-const REQUEST_METADATA_MAX_ENTRIES = 16;
-const REQUEST_METADATA_MAX_LENGTH = 256;
-/**
-* Bedrock rejects the whole invocation on a malformed `requestMetadata` entry.
-* Attribution tags must never cost a turn, so invalid and excess entries are
-* dropped with a warning instead of failing the request. Returns `undefined`
-* for an empty result so the field is omitted from the body entirely.
-*/
-function sanitizeRequestMetadata(raw) {
-	if (!isRecord(raw)) return void 0;
-	const out = {};
-	const dropped = [];
-	let kept = 0;
-	for (const [key, value] of Object.entries(raw)) {
-		if (typeof value !== "string" || key.length < 1 || key.length > REQUEST_METADATA_MAX_LENGTH || !REQUEST_METADATA_PATTERN.test(key) || value.length > REQUEST_METADATA_MAX_LENGTH || !REQUEST_METADATA_PATTERN.test(value) || kept >= REQUEST_METADATA_MAX_ENTRIES) {
-			dropped.push(key);
-			continue;
-		}
-		out[key] = value;
-		kept++;
-	}
-	if (dropped.length > 0) warn("Bedrock requestMetadata entries dropped", { keys: dropped });
-	return kept > 0 ? out : void 0;
-}
-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);
-			let toolConfig = toolPlan.toolConfig;
-			const sentinelInjected = toolPlan.sentinelInjected;
-			let additionalModelRequestFields = buildAdditionalModelRequestFields(model, options);
-			const prefixMismatchBehavior = model.thinking?.prefixBinding ? options.anthropicPrefixMismatchBehavior ?? "drop_block" : void 0;
-			if (toolConfig?.toolChoice && additionalModelRequestFields) {
-				const tc = toolConfig.toolChoice;
-				if (tc.any || tc.tool) {
-					if (prefixMismatchBehavior) toolConfig = {
-						...toolConfig,
-						toolChoice: { auto: {} }
-					};
-					else additionalModelRequestFields = void 0;
-				}
-			}
-			if (prefixMismatchBehavior) additionalModelRequestFields = applyBedrockThinkingBinding(additionalModelRequestFields, prefixMismatchBehavior);
-			let commandInput = {
-				messages: convertedMessages,
-				system: buildSystemPrompt(context.systemPrompt, promptCachePolicy),
-				inferenceConfig: {
-					maxTokens: options.maxTokens,
-					temperature: options.temperature,
-					topP: options.topP
-				},
-				toolConfig,
-				guardrailConfig: buildGuardrailConfig(options),
-				additionalModelRequestFields,
-				requestMetadata: model.requestMetadata || options.requestMetadata ? {
-					...model.requestMetadata,
-					...options.requestMetadata
-				} : void 0,
-				...prefixMismatchBehavior ? { additionalModelResponseFieldPaths: ["/input_transformations"] } : {}
-			};
-			const replacementInput = await options?.onPayload?.(commandInput, model);
-			if (replacementInput !== void 0) commandInput = replacementInput;
-			commandInput = {
-				...commandInput,
-				requestMetadata: sanitizeRequestMetadata(commandInput.requestMetadata)
-			};
-			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 source of [model.headers, options?.headers]) for (const [name, value] of Object.entries(source ?? {})) {
-				const field = name.toLowerCase();
-				if (SIGNER_OWNED_HEADERS.has(field) || BEDROCK_RESERVED_HEADERS.has(field)) continue;
-				callerHeaders[field] = value;
-			}
-			callerHeaders["user-agent"] ??= USER_AGENT;
-			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;
-						const responseFields = isRecord(ev.additionalModelResponseFields) ? ev.additionalModelResponseFields : void 0;
-						const transformations = parseAnthropicInputTransformations(responseFields?.input_transformations);
-						if (transformations.length > 0) {
-							output.inputTransformations = transformations;
-							for (const transformation of transformations) {
-								if (transformation.reason !== "prefix_binding_mismatch") continue;
-								warn("bedrock: dropped thinking block after conversation prefix changed", {
-									model: model.id,
-									path: transformation.path
-								});
-							}
-						}
-						output.stopReason = sentinelInjected && ev.stopReason === "tool_use" ? "stop" : mapStopReason(ev.stopReason);
-						if (output.stopReason === "error") output.errorMessage = ev.stopReason === "guardrail_intervened" ? `Response blocked by Amazon Bedrock guardrail (stop reason: ${ev.stopReason}).` : ev.stopReason === "content_filtered" ? `Response filtered by Amazon Bedrock content filters (stop reason: ${ev.stopReason}).` : `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, output.timestamp);
-	}
-}
-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 } : {}
-	} };
-}
-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 && !c.thinkingSignature) continue;
-						if (c.thinkingSignature) contentBlocks.push({ reasoningContent: { reasoningText: {
-							text: c.thinking.toWellFormed(),
-							signature: c.thinkingSignature
-						} } });
-						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";
-	}
-}
-/**
-* Build the Converse `guardrailConfig` block when a guardrail identifier is set.
-* The version defaults to `"DRAFT"` (Bedrock's editable working draft) and the
-* trace is passed through untouched — leaving it undefined keeps Bedrock's own
-* default rather than forcing a value.
-*/
-function buildGuardrailConfig(options) {
-	if (!options.guardrailIdentifier) return void 0;
-	return {
-		guardrailIdentifier: options.guardrailIdentifier,
-		guardrailVersion: options.guardrailVersion ?? "DRAFT",
-		...options.guardrailTrace === void 0 ? {} : { trace: options.guardrailTrace }
-	};
-}
-function applyBedrockThinkingBinding(fields, behavior) {
-	const result = { ...fields };
-	const thinking = isRecord(result.thinking) ? { ...result.thinking } : { type: "adaptive" };
-	thinking.block_binding = { prefix_mismatch_behavior: behavior };
-	result.thinking = thinking;
-	const betas = Array.isArray(result.anthropic_beta) ? result.anthropic_beta.filter((beta) => typeof beta === "string") : [];
-	if (!betas.includes("thinking-binding-controls-2026-08-01")) betas.push(THINKING_BINDING_CONTROLS_BETA);
-	result.anthropic_beta = betas;
-	return result;
-}
-function buildAdditionalModelRequestFields(model, options) {
-	const reasoning = options.reasoning;
-	if (!reasoning || !model.reasoning) return void 0;
-	const mode = model.thinking?.mode;
-	if (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 }
-		};
-	}
-	if (mode === "effort") {
-		const level = requireSupportedEffort(model, reasoning);
-		return { reasoning: { effort: model.thinking?.effortMap?.[level] ?? level } };
-	}
-	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 };