@warlock.js/ai-bedrock 4.1.1

package/cjs/index.cjs

@@ -0,0 +1,808 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _aws_sdk_client_bedrock_runtime = require("@aws-sdk/client-bedrock-runtime");
+let _warlock_js_ai = require("@warlock.js/ai");
+let _warlock_js_logger = require("@warlock.js/logger");
+
+//#region ../../@warlock.js/ai-bedrock/src/utils/map-stop-reason.ts
+const stopReasonMap = {
+	end_turn: "stop",
+	stop_sequence: "stop",
+	max_tokens: "length",
+	tool_use: "tool_calls"
+};
+/**
+* Map Bedrock Converse's `stopReason` to the normalized `FinishReason`
+* union.
+*
+* `end_turn` / `stop_sequence` are natural stops. `max_tokens` maps to
+* `length`. `tool_use` maps to `tool_calls`. Everything else —
+* `content_filtered`, `guardrail_intervened`, `malformed_tool_use`,
+* `malformed_model_output`, `model_context_window_exceeded`, `null`,
+* or any future value — falls through to `"error"`: none produced a
+* clean terminal answer, so the agent must not treat them as success.
+*
+* @example
+* mapStopReason("end_turn");              // "stop"
+* mapStopReason("tool_use");              // "tool_calls"
+* mapStopReason("guardrail_intervened");  // "error"
+* mapStopReason(undefined);               // "error"
+*/
+function mapStopReason(raw) {
+	return stopReasonMap[raw ?? ""] ?? "error";
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-bedrock/src/utils/to-bedrock-messages.ts
+const MEDIA_TYPE_TO_FORMAT = {
+	"image/jpeg": "jpeg",
+	"image/png": "png",
+	"image/gif": "gif",
+	"image/webp": "webp"
+};
+/**
+* Convert vendor-neutral `Message[]` into Bedrock Converse's request
+* shape.
+*
+* Converse differs from the OpenAI Chat protocol in three ways this
+* function absorbs:
+*
+* 1. **No `system` role.** System messages become a separate
+*    `SystemContentBlock[]` (one `{ text }` block each).
+* 2. **Tool results are `user` turns.** A neutral `tool` message
+*    becomes a `user` message carrying a single `toolResult` block.
+* 3. **Tool calls are `toolUse` content blocks.** An assistant message
+*    with `toolCalls` becomes an `assistant` message: an optional
+*    leading `text` block followed by one `toolUse` block per call.
+*
+* @example
+* const { system, messages } = toBedrockMessages([
+*   { role: "system", content: "Be concise." },
+*   { role: "user", content: "Hi" },
+* ]);
+*/
+function toBedrockMessages(messages) {
+	const system = [];
+	const mapped = [];
+	for (const message of messages) {
+		if (message.role === "system") {
+			system.push({ text: stringifyContent(message.content) });
+			continue;
+		}
+		if (message.role === "tool") {
+			mapped.push({
+				role: "user",
+				content: [{ toolResult: {
+					toolUseId: message.toolCallId ?? "",
+					content: [{ text: stringifyContent(message.content) }]
+				} }]
+			});
+			continue;
+		}
+		if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+			const blocks = [];
+			const text = stringifyContent(message.content);
+			if (text) blocks.push({ text });
+			for (const toolCall of message.toolCalls) blocks.push({ toolUse: {
+				toolUseId: toolCall.id,
+				name: toolCall.name,
+				input: toolCall.input ?? {}
+			} });
+			mapped.push({
+				role: "assistant",
+				content: blocks
+			});
+			continue;
+		}
+		if (message.role === "user" && Array.isArray(message.content)) {
+			mapped.push({
+				role: "user",
+				content: message.content.map(toBedrockContentBlock)
+			});
+			continue;
+		}
+		mapped.push({
+			role: message.role === "assistant" ? "assistant" : "user",
+			content: [{ text: stringifyContent(message.content) }]
+		});
+	}
+	return {
+		system: system.length > 0 ? system : void 0,
+		messages: mapped
+	};
+}
+/**
+* Multipart content is only meaningful on user messages — for any other
+* role collapse a `ContentPart[]` to its concatenated text. Plain
+* strings pass through unchanged.
+*/
+function stringifyContent(content) {
+	if (typeof content === "string") return content;
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+/**
+* Map a resolved `ContentPart` to a Bedrock `ContentBlock`. Bedrock's
+* `ImageSource` only accepts raw bytes or an S3 location — there is no
+* remote-URL source. A neutral `{ url }` image therefore cannot be
+* sent and surfaces a typed `InvalidRequestError` upfront rather than
+* a downstream Bedrock validation fault. The agent has already
+* resolved attachments, so this never fetches or reads anything.
+*/
+function toBedrockContentBlock(part) {
+	if (part.type === "text") return { text: part.text };
+	if ("url" in part.source) throw new _warlock_js_ai.InvalidRequestError("Bedrock Converse does not support remote-URL image sources; supply base64 image bytes instead.");
+	const format = MEDIA_TYPE_TO_FORMAT[part.source.mediaType];
+	if (!format) throw new _warlock_js_ai.InvalidRequestError(`Unsupported image media type for Bedrock: "${part.source.mediaType}" (expected image/jpeg, image/png, image/gif, or image/webp).`);
+	return { image: {
+		format,
+		source: { bytes: Buffer.from(part.source.base64, "base64") }
+	} };
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-bedrock/src/utils/to-bedrock-tools.ts
+/**
+* Convert vendor-neutral `ToolConfig[]` into Bedrock Converse's
+* `ToolConfiguration`. Each tool becomes a `toolSpec` with a JSON
+* `inputSchema`. Bedrock requires the schema root to be an object —
+* a non-object extraction degrades to a parameterless object schema
+* so registration never fails.
+*
+* Returns `undefined` when there are no tools so the caller can omit
+* `toolConfig` from the request entirely (Bedrock rejects an empty
+* `tools` array).
+*
+* @example
+* const toolConfig = toBedrockToolConfig([weatherTool]);
+* await client.send(new ConverseCommand({ modelId, messages, toolConfig }));
+*/
+function toBedrockToolConfig(tools) {
+	if (!tools || tools.length === 0) return;
+	return { tools: tools.map((tool) => ({ toolSpec: {
+		name: tool.name,
+		description: tool.description,
+		inputSchema: { json: toJsonSchema(tool.input) }
+	} })) };
+}
+/**
+* Resolve a tool's input schema to a JSON-Schema object. Bedrock's
+* `ToolInputSchema.json` requires an object root; anything else (or a
+* failed extraction) degrades to a parameterless object so the tool
+* still registers.
+*/
+function toJsonSchema(input) {
+	const schema = (0, _warlock_js_ai.extractJsonSchema)(input);
+	if (schema && schema.type === "object") return schema;
+	return { type: "object" };
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-bedrock/src/utils/wrap-bedrock-error.ts
+const TIMEOUT_NAMES = new Set([
+	"ModelTimeoutException",
+	"TimeoutError",
+	"RequestTimeout",
+	"RequestTimeoutException"
+]);
+/**
+* Wrap any thrown value caught inside the Bedrock adapter into the
+* appropriate `@warlock.js/ai` `AIError` subclass.
+*
+* **Dispatch strategy.** AWS errors carry no provider machine `code`;
+* the stable identifier is the Smithy exception `name`. Dispatch keys
+* on `name`, falls back to `$metadata.httpStatusCode` when the name is
+* missing (flattened/proxied errors). `ValidationException` is split:
+* the "input is too long / exceeds context window" phrasing maps to
+* `ContextLengthExceededError`, everything else to
+* `InvalidRequestError`.
+*
+* `AIError` instances pass through unchanged so `catch/throw wrap(e)`
+* pipelines never double-wrap.
+*
+* @example
+* try {
+*   return await this.client.send(new ConverseCommand(...));
+* } catch (thrown) {
+*   throw wrapBedrockError(thrown);
+* }
+*/
+function wrapBedrockError(thrown) {
+	if (thrown instanceof _warlock_js_ai.AIError) return thrown;
+	const shape = toShape(thrown);
+	const context = buildContext(shape);
+	const message = shape.message ?? (thrown instanceof Error ? thrown.message : String(thrown));
+	if (isTimeout(shape)) return new _warlock_js_ai.ProviderTimeoutError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.name === "AccessDeniedException" || shape.httpStatusCode === 403) return new _warlock_js_ai.ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.httpStatusCode === 401) return new _warlock_js_ai.ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.name === "ServiceQuotaExceededException") return new _warlock_js_ai.QuotaExceededError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.name === "ThrottlingException" || shape.httpStatusCode === 429) return new _warlock_js_ai.ProviderRateLimitError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.name === "ValidationException") {
+		if (/too long|context window|maximum context|exceeds the maximum/i.test(message)) return new _warlock_js_ai.ContextLengthExceededError(message, {
+			cause: thrown,
+			context
+		});
+		return new _warlock_js_ai.InvalidRequestError(message, {
+			cause: thrown,
+			context
+		});
+	}
+	if (shape.name === "ResourceNotFoundException" || shape.name === "ConflictException" || isClientStatus(shape.httpStatusCode)) return new _warlock_js_ai.InvalidRequestError(message, {
+		cause: thrown,
+		context
+	});
+	return new _warlock_js_ai.ProviderError(message, {
+		cause: thrown,
+		context
+	});
+}
+/**
+* Read the raw error shape without depending on `instanceof`. AWS
+* exceptions expose `$metadata`; plain/proxied errors may carry
+* `status` / `code` instead.
+*/
+function toShape(thrown) {
+	if (typeof thrown !== "object" || thrown === null) return {};
+	const raw = thrown;
+	const metadata = raw.$metadata;
+	return {
+		name: typeof raw.name === "string" ? raw.name : void 0,
+		message: typeof raw.message === "string" ? raw.message : void 0,
+		httpStatusCode: metadata && typeof metadata.httpStatusCode === "number" ? metadata.httpStatusCode : typeof raw.status === "number" ? raw.status : void 0,
+		requestId: metadata && typeof metadata.requestId === "string" ? metadata.requestId : void 0,
+		code: typeof raw.code === "string" ? raw.code : void 0
+	};
+}
+/**
+* Decide whether the error is a timeout. Bedrock surfaces
+* `ModelTimeoutException`; the AWS transport layer surfaces
+* `TimeoutError` / `ETIMEDOUT` / `ECONNABORTED`.
+*/
+function isTimeout(shape) {
+	if (shape.name && TIMEOUT_NAMES.has(shape.name)) return true;
+	return shape.code === "ETIMEDOUT" || shape.code === "ECONNABORTED";
+}
+/** True for HTTP 4xx — a client-side request problem, not a server fault. */
+function isClientStatus(status) {
+	return typeof status === "number" && status >= 400 && status < 500;
+}
+/**
+* Attach the raw diagnostic fields to `error.context`. The Smithy
+* exception `name` is the closest thing Bedrock has to a stable error
+* code, so it lands on `context.code`.
+*/
+function buildContext(shape) {
+	const context = {};
+	if (shape.httpStatusCode !== void 0) context.status = shape.httpStatusCode;
+	if (shape.name) context.code = shape.name;
+	if (shape.requestId) context.requestId = shape.requestId;
+	return context;
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-bedrock/src/embedder.ts
+const LOG_MODULE$1 = "ai.bedrock";
+/**
+* Bedrock-backed implementation of `EmbedderContract`, targeting the
+* Amazon Titan Text Embeddings family
+* (`amazon.titan-embed-text-v2:0` / v1) via `InvokeModel`.
+*
+* **Role.** Converts text into floating-point vectors. Standalone
+* primitive — unrelated to Converse / tools / the agent loop.
+*
+* **Single-input only upstream.** Titan's `InvokeModel` body accepts
+* one `inputText` per call — there is no batch endpoint. `embedMany`
+* therefore issues one request per input sequentially and aggregates
+* token usage. This is a deliberate, documented trade-off: a real
+* batch API does not exist for Titan on Bedrock, so the alternative
+* (failing `embedMany`) would be worse. Cohere embeddings on Bedrock
+* *do* batch but use an incompatible body shape — out of scope; use
+* the OpenAI adapter or a future Cohere adapter when batch throughput
+* matters.
+*
+* **Dimensions.** When no `dimensions` override is given,
+* `this.dimensions` starts at `0` and is populated from the first
+* response's vector length, then cached. Passing `dimensions` forwards
+* Titan v2's truncation hint (256 / 512 / 1024) and sets the initial
+* value immediately.
+*
+* @example
+* const embedder = new BedrockEmbedder(client, { name: "amazon.titan-embed-text-v2:0" });
+* const { vector } = await embedder.embed("Hello world");
+* const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
+*/
+var BedrockEmbedder = class {
+	constructor(client, config, provider = "bedrock") {
+		this.logger = _warlock_js_logger.log;
+		this.client = client;
+		this.name = config.name;
+		this.provider = provider;
+		this.configuredDimensions = config.dimensions;
+		this.dimensions = config.dimensions ?? 0;
+	}
+	async embed(input) {
+		const { vector, tokens } = await this.invoke(input);
+		return {
+			vector,
+			dimensions: this.dimensions,
+			usage: {
+				promptTokens: tokens,
+				totalTokens: tokens
+			}
+		};
+	}
+	async embedMany(inputs) {
+		const vectors = [];
+		let tokens = 0;
+		for (const input of inputs) {
+			const result = await this.invoke(input);
+			vectors.push(result.vector);
+			tokens += result.tokens;
+		}
+		const usage = {
+			promptTokens: tokens,
+			totalTokens: tokens
+		};
+		return {
+			vectors,
+			dimensions: this.dimensions,
+			usage
+		};
+	}
+	/**
+	* Issue a single Titan `InvokeModel` embedding request: encode the
+	* JSON body, send, wrap provider errors, decode the response, and
+	* cache `dimensions` on the first successful call.
+	*/
+	async invoke(input) {
+		this.logger.debug(LOG_MODULE$1, "embedder.request", "InvokeModel embeddings", { model: this.name });
+		const body = JSON.stringify({
+			inputText: input,
+			...this.configuredDimensions !== void 0 ? { dimensions: this.configuredDimensions } : {}
+		});
+		let raw;
+		try {
+			raw = await this.client.send(new _aws_sdk_client_bedrock_runtime.InvokeModelCommand({
+				modelId: this.name,
+				contentType: "application/json",
+				accept: "application/json",
+				body: new TextEncoder().encode(body)
+			}));
+		} catch (thrown) {
+			const wrapped = wrapBedrockError(thrown);
+			this.logger.error(LOG_MODULE$1, "embedder.error", wrapped.message, {
+				code: wrapped.code,
+				context: wrapped.context
+			});
+			throw wrapped;
+		}
+		const decoded = JSON.parse(new TextDecoder().decode(raw.body));
+		if (this.dimensions === 0) this.dimensions = decoded.embedding.length;
+		this.logger.debug(LOG_MODULE$1, "embedder.response", "InvokeModel embeddings returned", {
+			dimensions: decoded.embedding.length,
+			tokens: decoded.inputTextTokenCount
+		});
+		return {
+			vector: decoded.embedding,
+			tokens: decoded.inputTextTokenCount
+		};
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/ai-bedrock/src/known-vision-models.ts
+/**
+* Substrings that identify Bedrock model ids whose family accepts image
+* input on the Converse API.
+*
+* Bedrock model ids are provider-prefixed and version-suffixed
+* (`anthropic.claude-3-5-sonnet-20240620-v1:0`, `us.amazon.nova-pro-v1:0`,
+* `meta.llama3-2-90b-instruct-v1:0`), so a substring match is the only
+* robust check across the cross-region inference-profile prefixes
+* (`us.`, `eu.`, `apac.`) and date/version tags.
+*
+* Multimodal families covered: Anthropic Claude 3 / 3.5 / 3.7 / 4,
+* Amazon Nova Lite/Pro/Premier, Meta Llama 3.2 (11B/90B) and Llama 4.
+* Text-only families (Llama 3/3.1, Titan Text, Mistral 7B, Cohere
+* Command) are intentionally absent. Override per-model via
+* `bedrock.model({ name, vision: true | false })`.
+*/
+const VISION_CAPABLE_SUBSTRINGS = [
+	"claude-3",
+	"claude-sonnet-4",
+	"claude-opus-4",
+	"claude-haiku-4",
+	"nova-lite",
+	"nova-pro",
+	"nova-premier",
+	"llama3-2-11b",
+	"llama3-2-90b",
+	"llama4"
+];
+/**
+* Infer whether a Bedrock model id supports vision based on the known
+* multimodal-family substrings. Unknown ids default to `false` so that
+* passing an image attachment to an unsupported model surfaces a clear,
+* agent-side capability error instead of an opaque Bedrock validation
+* fault.
+*
+* @example
+* inferVisionCapability("anthropic.claude-3-5-sonnet-20240620-v1:0"); // → true
+* inferVisionCapability("us.amazon.nova-pro-v1:0");                    // → true
+* inferVisionCapability("meta.llama3-1-8b-instruct-v1:0");             // → false
+* inferVisionCapability("amazon.titan-text-express-v1");               // → false
+*/
+function inferVisionCapability(modelId) {
+	const normalized = modelId.toLowerCase();
+	return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-bedrock/src/model.ts
+const LOG_MODULE = "ai.bedrock";
+/**
+* Bedrock-backed implementation of `ModelContract`.
+*
+* **Role.** The provider-facing bridge between the vendor-neutral
+* `@warlock.js/ai` agent runtime and AWS Bedrock's Converse /
+* ConverseStream API. Converse is the model-agnostic surface — one
+* wire mapping covers every Bedrock-hosted family (Anthropic Claude,
+* Amazon Nova, Meta Llama, Mistral, Cohere) instead of per-family
+* `InvokeModel` body shapes.
+*
+* **Responsibility.**
+* - Owns: a long-lived `BedrockRuntimeClient` + frozen `ModelConfig`
+*   (modelId, temperature, maxTokens) used as per-call defaults.
+* - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into
+*   Converse shapes (system hoisting, `toolUse` / `toolResult` blocks,
+*   image bytes) on the way out, and Converse's content-block response
+*   (text, tool calls, stop reason, token usage) back into the neutral
+*   shapes on the way in.
+* - Does NOT own: dispatching tools, looping, history, retries — those
+*   are agent concerns. The model is a per-call protocol adapter.
+*
+* Modeled as a class (see §4.2 of code-style.md — "long-lived state
+* across calls"): the AWS client is heavy to construct and reused for
+* the SDK's lifetime.
+*
+* @example
+* import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+* const client = new BedrockRuntimeClient({ region: "us-east-1" });
+* const model = new BedrockModel(client, {
+*   name: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+* });
+*
+* const myAgent = agent({ model, tools: [searchTool] });
+* const result = await myAgent.execute("Summarize today's news.");
+*/
+var BedrockModel = class {
+	constructor(client, config, provider = "bedrock") {
+		this.logger = _warlock_js_logger.log;
+		this.client = client;
+		this.config = config;
+		this.name = config.name;
+		this.provider = provider;
+		this.pricing = config.pricing;
+		this.capabilities = {
+			structuredOutput: config.structuredOutput ?? true,
+			vision: config.vision ?? inferVisionCapability(config.name)
+		};
+	}
+	/**
+	* Single-shot completion via the Converse API. Sends the full
+	* message list, waits for the terminal response, and reshapes it
+	* into a vendor-neutral `ModelResponse`. Per-call `options` override
+	* the instance defaults for this call only.
+	*/
+	async complete(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting Converse call", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: false,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let response;
+		try {
+			response = await this.client.send(new _aws_sdk_client_bedrock_runtime.ConverseCommand(this.buildRequest(messages, options)), options?.signal ? { abortSignal: options.signal } : void 0);
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const blocks = response.output?.message?.content ?? [];
+		const finishReason = mapStopReason(response.stopReason);
+		const usage = this.extractUsage(response.usage);
+		const toolCalls = this.extractToolCalls(blocks);
+		this.logger.debug(LOG_MODULE, "response", "Converse call succeeded", {
+			finishReason,
+			usage
+		});
+		return {
+			content: this.extractText(blocks),
+			finishReason,
+			usage,
+			toolCalls
+		};
+	}
+	/**
+	* Incremental streaming completion via ConverseStream. Yields neutral
+	* `ModelStreamChunk`s — `delta` for text, `tool-call` once a
+	* `toolUse` block's accumulated input JSON is complete, and a
+	* terminal `done` with the final finish reason + usage totals.
+	*/
+	async *stream(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting ConverseStream call", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: true,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let response;
+		try {
+			response = await this.client.send(new _aws_sdk_client_bedrock_runtime.ConverseStreamCommand(this.buildRequest(messages, options)), options?.signal ? { abortSignal: options.signal } : void 0);
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		let rawStopReason;
+		const usage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		const toolBlocks = /* @__PURE__ */ new Map();
+		try {
+			for await (const event of response.stream ?? []) {
+				if (event.contentBlockStart?.start?.toolUse) {
+					const start = event.contentBlockStart.start.toolUse;
+					toolBlocks.set(event.contentBlockStart.contentBlockIndex ?? 0, {
+						id: start.toolUseId ?? "",
+						name: start.name ?? "",
+						json: ""
+					});
+					continue;
+				}
+				if (event.contentBlockDelta?.delta) {
+					const delta = event.contentBlockDelta.delta;
+					if (delta.text) yield {
+						type: "delta",
+						content: delta.text
+					};
+					else if (delta.toolUse) {
+						const accumulator = toolBlocks.get(event.contentBlockDelta.contentBlockIndex ?? 0);
+						if (accumulator) accumulator.json += delta.toolUse.input ?? "";
+					}
+					continue;
+				}
+				if (event.contentBlockStop) {
+					const accumulator = toolBlocks.get(event.contentBlockStop.contentBlockIndex ?? 0);
+					if (accumulator) {
+						yield {
+							type: "tool-call",
+							id: accumulator.id,
+							name: accumulator.name,
+							input: (0, _warlock_js_ai.safeJsonParse)(accumulator.json, {})
+						};
+						toolBlocks.delete(event.contentBlockStop.contentBlockIndex ?? 0);
+					}
+					continue;
+				}
+				if (event.messageStop) rawStopReason = event.messageStop.stopReason;
+				if (event.metadata?.usage) {
+					const raw = event.metadata.usage;
+					usage.input = raw.inputTokens ?? 0;
+					usage.output = raw.outputTokens ?? 0;
+					usage.total = raw.totalTokens ?? usage.input + usage.output;
+					if (raw.cacheReadInputTokens && raw.cacheReadInputTokens > 0) usage.cachedTokens = raw.cacheReadInputTokens;
+				}
+			}
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const finishReason = mapStopReason(rawStopReason);
+		this.logger.debug(LOG_MODULE, "response", "ConverseStream call succeeded", {
+			finishReason,
+			usage
+		});
+		yield {
+			type: "done",
+			finishReason,
+			usage
+		};
+	}
+	/**
+	* Assemble the Converse request shared by `complete()` and
+	* `stream()` (both command shapes take the same input). Hoists the
+	* system prompt, maps inference params, and conditionally attaches
+	* tools and native structured output.
+	*/
+	buildRequest(messages, options) {
+		const { system, messages: bedrockMessages } = toBedrockMessages(messages);
+		const maxTokens = options?.maxTokens ?? this.config.maxTokens;
+		const temperature = options?.temperature ?? this.config.temperature;
+		return {
+			modelId: this.name,
+			messages: bedrockMessages,
+			...system ? { system } : {},
+			inferenceConfig: {
+				...maxTokens !== void 0 ? { maxTokens } : {},
+				...temperature !== void 0 ? { temperature } : {}
+			},
+			...this.buildToolConfig(options?.tools),
+			...this.buildOutputConfig(options?.responseSchema)
+		};
+	}
+	/**
+	* Spread-friendly tool fragment. Returns an empty object when no
+	* tools were supplied (Bedrock rejects an empty `tools` array).
+	*/
+	buildToolConfig(tools) {
+		const toolConfig = toBedrockToolConfig(tools);
+		return toolConfig ? { toolConfig } : {};
+	}
+	/**
+	* Translate the neutral `responseSchema` into Converse's native
+	* `outputConfig.textFormat` (JSON-schema structured output). Bedrock
+	* requires the schema as a stringified JSON document and only
+	* accepts an object root. Emitted only when the model is
+	* `structuredOutput`-capable and the schema is an object — otherwise
+	* the agent's soft system-prompt hint + client-side `validate()`
+	* carry shape (same degradation philosophy as the OpenAI adapter).
+	*/
+	buildOutputConfig(responseSchema) {
+		if (!responseSchema || !this.capabilities.structuredOutput) return {};
+		if (responseSchema.type !== "object" || typeof responseSchema.properties !== "object") return {};
+		return { outputConfig: { textFormat: {
+			type: "json_schema",
+			structure: { jsonSchema: {
+				name: "response",
+				schema: JSON.stringify(responseSchema)
+			} }
+		} } };
+	}
+	/**
+	* Concatenate every `text` content block into the single neutral
+	* `content` string. `toolUse` and other block types are surfaced
+	* separately via `extractToolCalls`.
+	*/
+	extractText(blocks) {
+		return blocks.map((block) => "text" in block && typeof block.text === "string" ? block.text : "").join("");
+	}
+	/**
+	* Reshape Converse `toolUse` content blocks into the neutral
+	* `ModelToolCallRequest[]`. Returns `undefined` when no tools were
+	* requested so callers can branch on presence.
+	*/
+	extractToolCalls(blocks) {
+		const toolCalls = [];
+		for (const block of blocks) if ("toolUse" in block && block.toolUse) toolCalls.push({
+			id: block.toolUse.toolUseId ?? "",
+			name: block.toolUse.name ?? "",
+			input: block.toolUse.input ?? {}
+		});
+		return toolCalls.length > 0 ? toolCalls : void 0;
+	}
+	/**
+	* Normalize Converse's `TokenUsage` into the neutral `Usage` shape.
+	* Bedrock supplies a pre-summed `totalTokens`; cache-read tokens are
+	* surfaced as `cachedTokens` only when non-zero.
+	*/
+	extractUsage(raw) {
+		if (!raw) return {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		const input = raw.inputTokens ?? 0;
+		const output = raw.outputTokens ?? 0;
+		const cached = raw.cacheReadInputTokens;
+		return {
+			input,
+			output,
+			total: raw.totalTokens ?? input + output,
+			...cached && cached > 0 ? { cachedTokens: cached } : {}
+		};
+	}
+	/**
+	* Wrap a thrown provider error into the typed `AIError` hierarchy
+	* and emit the standard error log line before it propagates. Shared
+	* by every catch site so the log shape stays identical.
+	*/
+	logAndWrap(thrown) {
+		const wrapped = wrapBedrockError(thrown);
+		this.logger.error(LOG_MODULE, "error", wrapped.message, {
+			code: wrapped.code,
+			context: wrapped.context
+		});
+		return wrapped;
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/ai-bedrock/src/sdk.ts
+/**
+* AWS Bedrock-backed implementation of `SDKAdapterContract`.
+*
+* **Role.** The package entry point for any Bedrock-hosted model via
+* the Converse API. A single `BedrockSDK` holds one live
+* `BedrockRuntimeClient`, shared by every `ModelContract` and
+* `EmbedderContract` it produces. Construct one SDK per AWS
+* account/region and reuse it everywhere.
+*
+* **Responsibility.**
+* - Owns: a long-lived `BedrockRuntimeClient` (region, credential
+*   chain) and its lifetime. Factory for `BedrockModel` /
+*   `BedrockEmbedder` instances sharing that client.
+* - Does NOT own: anything per-call — those live in `BedrockModel` /
+*   `BedrockEmbedder` and the agent runtime.
+*
+* Modeled as a class (see §4.2 of code-style.md — "long-lived state
+* across many calls"): the AWS client is heavy to construct and
+* designed for reuse; keeping it on `this` aligns with the
+* `new BedrockRuntimeClient(...)` upstream convention.
+*
+* @example
+* const bedrock = new BedrockSDK({ region: "us-east-1" });
+* const model = bedrock.model({ name: "anthropic.claude-sonnet-4-5-20250929-v1:0" });
+* const embedder = bedrock.embedder({ name: "amazon.titan-embed-text-v2:0" });
+*/
+var BedrockSDK = class {
+	constructor(config) {
+		const { provider, pricing, ...clientConfig } = config;
+		this.client = new _aws_sdk_client_bedrock_runtime.BedrockRuntimeClient(clientConfig);
+		this.provider = provider ?? "bedrock";
+		this.pricing = pricing;
+	}
+	/**
+	* Build a `BedrockModel` bound to this SDK's client. Each call
+	* returns a fresh instance; all instances share the underlying AWS
+	* client so connection pools, credential refresh, and retry config
+	* stay unified. The SDK's `provider` label is forwarded.
+	*
+	* Pricing resolution: per-model `config.pricing` wins; otherwise the
+	* SDK-level registry entry keyed by `config.name`; otherwise
+	* `undefined` (no cost computed).
+	*/
+	model(config) {
+		const resolvedPricing = config.pricing ?? this.pricing?.[config.name];
+		const resolvedConfig = resolvedPricing === config.pricing ? config : {
+			...config,
+			pricing: resolvedPricing
+		};
+		return new BedrockModel(this.client, resolvedConfig, this.provider);
+	}
+	/**
+	* Rough token-count estimate. Uses the character-heuristic
+	* (`approximateTokenCount`) from the core package — Bedrock has no
+	* offline tokenizer and the per-model tokenizers differ; good enough
+	* for budgeting and quota guards, not for billing.
+	*/
+	async count(text, _model) {
+		return (0, _warlock_js_ai.approximateTokenCount)(text);
+	}
+	/**
+	* Build a `BedrockEmbedder` (Amazon Titan Text Embeddings) bound to
+	* this SDK's client.
+	*
+	* @example
+	* const embedder = bedrock.embedder({ name: "amazon.titan-embed-text-v2:0" });
+	* const { vector } = await embedder.embed("Hello world");
+	*/
+	embedder(config) {
+		return new BedrockEmbedder(this.client, config, this.provider);
+	}
+};
+
+//#endregion
+exports.BedrockSDK = BedrockSDK;
+//# sourceMappingURL=index.cjs.map