@warlock.js/ai-bedrock 4.1.1

package/esm/model.mjs

@@ -0,0 +1,290 @@
+import { mapStopReason } from "./utils/map-stop-reason.mjs";
+import { toBedrockMessages } from "./utils/to-bedrock-messages.mjs";
+import { toBedrockToolConfig } from "./utils/to-bedrock-tools.mjs";
+import { wrapBedrockError } from "./utils/wrap-bedrock-error.mjs";
+import "./utils/index.mjs";
+import { inferVisionCapability } from "./known-vision-models.mjs";
+import { ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
+import { safeJsonParse } from "@warlock.js/ai";
+import { log } from "@warlock.js/logger";
+
+//#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 = 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 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 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: 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
+export { BedrockModel };
+//# sourceMappingURL=model.mjs.map

package/esm/model.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.mjs","names":[],"sources":["../../../../../@warlock.js/ai-bedrock/src/model.ts"],"sourcesContent":["import {\n  safeJsonParse,\n  type Message,\n  type ModelCallOptions,\n  type ModelCapabilities,\n  type ModelContract,\n  type ModelPricing,\n  type ModelResponse,\n  type ModelStreamChunk,\n  type ModelToolCallRequest,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport {\n  ConverseCommand,\n  ConverseStreamCommand,\n  type BedrockRuntimeClient,\n  type ContentBlock,\n  type ConverseRequest,\n  type TokenUsage,\n} from \"@aws-sdk/client-bedrock-runtime\";\nimport type { BedrockModelConfig } from \"./config.type\";\nimport { inferVisionCapability } from \"./known-vision-models\";\nimport { mapStopReason, toBedrockMessages, toBedrockToolConfig, wrapBedrockError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.bedrock\";\n\n/**\n * Bedrock-backed implementation of `ModelContract`.\n *\n * **Role.** The provider-facing bridge between the vendor-neutral\n * `@warlock.js/ai` agent runtime and AWS Bedrock's Converse /\n * ConverseStream API. Converse is the model-agnostic surface — one\n * wire mapping covers every Bedrock-hosted family (Anthropic Claude,\n * Amazon Nova, Meta Llama, Mistral, Cohere) instead of per-family\n * `InvokeModel` body shapes.\n *\n * **Responsibility.**\n * - Owns: a long-lived `BedrockRuntimeClient` + frozen `ModelConfig`\n *   (modelId, temperature, maxTokens) used as per-call defaults.\n * - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into\n *   Converse shapes (system hoisting, `toolUse` / `toolResult` blocks,\n *   image bytes) on the way out, and Converse's content-block response\n *   (text, tool calls, stop reason, token usage) back into the neutral\n *   shapes on the way in.\n * - Does NOT own: dispatching tools, looping, history, retries — those\n *   are agent concerns. The model is a per-call protocol adapter.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across calls\"): the AWS client is heavy to construct and reused for\n * the SDK's lifetime.\n *\n * @example\n * import { BedrockRuntimeClient } from \"@aws-sdk/client-bedrock-runtime\";\n * const client = new BedrockRuntimeClient({ region: \"us-east-1\" });\n * const model = new BedrockModel(client, {\n *   name: \"anthropic.claude-sonnet-4-5-20250929-v1:0\",\n * });\n *\n * const myAgent = agent({ model, tools: [searchTool] });\n * const result = await myAgent.execute(\"Summarize today's news.\");\n */\nexport class BedrockModel implements ModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly capabilities: ModelCapabilities;\n  public readonly pricing?: ModelPricing;\n\n  private readonly client: BedrockRuntimeClient;\n  private readonly config: BedrockModelConfig;\n  private readonly logger: Logger = log;\n\n  public constructor(\n    client: BedrockRuntimeClient,\n    config: BedrockModelConfig,\n    provider: string = \"bedrock\",\n  ) {\n    this.client = client;\n    this.config = config;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.capabilities = {\n      structuredOutput: config.structuredOutput ?? true,\n      vision: config.vision ?? inferVisionCapability(config.name),\n    };\n  }\n\n  /**\n   * Single-shot completion via the Converse API. Sends the full\n   * message list, waits for the terminal response, and reshapes it\n   * into a vendor-neutral `ModelResponse`. Per-call `options` override\n   * the instance defaults for this call only.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting Converse call\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: false,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response;\n\n    try {\n      response = await this.client.send(\n        new ConverseCommand(this.buildRequest(messages, options)),\n        options?.signal ? { abortSignal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    const blocks = response.output?.message?.content ?? [];\n    const finishReason = mapStopReason(response.stopReason);\n    const usage = this.extractUsage(response.usage);\n    const toolCalls = this.extractToolCalls(blocks);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"Converse call succeeded\", { finishReason, usage });\n\n    return {\n      content: this.extractText(blocks),\n      finishReason,\n      usage,\n      toolCalls,\n    };\n  }\n\n  /**\n   * Incremental streaming completion via ConverseStream. Yields neutral\n   * `ModelStreamChunk`s — `delta` for text, `tool-call` once a\n   * `toolUse` block's accumulated input JSON is complete, and a\n   * terminal `done` with the final finish reason + usage totals.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting ConverseStream call\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: true,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response;\n\n    try {\n      response = await this.client.send(\n        new ConverseStreamCommand(this.buildRequest(messages, options)),\n        options?.signal ? { abortSignal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    let rawStopReason: string | undefined;\n    const usage: Usage = { input: 0, output: 0, total: 0 };\n    const toolBlocks = new Map<number, { id: string; name: string; json: string }>();\n\n    try {\n      for await (const event of response.stream ?? []) {\n        if (event.contentBlockStart?.start?.toolUse) {\n          const start = event.contentBlockStart.start.toolUse;\n\n          toolBlocks.set(event.contentBlockStart.contentBlockIndex ?? 0, {\n            id: start.toolUseId ?? \"\",\n            name: start.name ?? \"\",\n            json: \"\",\n          });\n\n          continue;\n        }\n\n        if (event.contentBlockDelta?.delta) {\n          const delta = event.contentBlockDelta.delta;\n\n          if (delta.text) {\n            yield { type: \"delta\", content: delta.text };\n          } else if (delta.toolUse) {\n            const accumulator = toolBlocks.get(event.contentBlockDelta.contentBlockIndex ?? 0);\n\n            if (accumulator) {\n              accumulator.json += delta.toolUse.input ?? \"\";\n            }\n          }\n\n          continue;\n        }\n\n        if (event.contentBlockStop) {\n          const accumulator = toolBlocks.get(event.contentBlockStop.contentBlockIndex ?? 0);\n\n          if (accumulator) {\n            yield {\n              type: \"tool-call\",\n              id: accumulator.id,\n              name: accumulator.name,\n              input: safeJsonParse<Record<string, unknown>>(accumulator.json, {}),\n            };\n\n            toolBlocks.delete(event.contentBlockStop.contentBlockIndex ?? 0);\n          }\n\n          continue;\n        }\n\n        if (event.messageStop) {\n          rawStopReason = event.messageStop.stopReason;\n        }\n\n        if (event.metadata?.usage) {\n          const raw = event.metadata.usage;\n\n          usage.input = raw.inputTokens ?? 0;\n          usage.output = raw.outputTokens ?? 0;\n          usage.total = raw.totalTokens ?? usage.input + usage.output;\n\n          if (raw.cacheReadInputTokens && raw.cacheReadInputTokens > 0) {\n            usage.cachedTokens = raw.cacheReadInputTokens;\n          }\n        }\n      }\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    const finishReason = mapStopReason(rawStopReason);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"ConverseStream call succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    yield { type: \"done\", finishReason, usage };\n  }\n\n  /**\n   * Assemble the Converse request shared by `complete()` and\n   * `stream()` (both command shapes take the same input). Hoists the\n   * system prompt, maps inference params, and conditionally attaches\n   * tools and native structured output.\n   */\n  private buildRequest(\n    messages: Message[],\n    options: ModelCallOptions | undefined,\n  ): ConverseRequest {\n    const { system, messages: bedrockMessages } = toBedrockMessages(messages);\n    const maxTokens = options?.maxTokens ?? this.config.maxTokens;\n    const temperature = options?.temperature ?? this.config.temperature;\n\n    return {\n      modelId: this.name,\n      messages: bedrockMessages,\n      ...(system ? { system } : {}),\n      inferenceConfig: {\n        ...(maxTokens !== undefined ? { maxTokens } : {}),\n        ...(temperature !== undefined ? { temperature } : {}),\n      },\n      ...this.buildToolConfig(options?.tools),\n      ...this.buildOutputConfig(options?.responseSchema),\n    };\n  }\n\n  /**\n   * Spread-friendly tool fragment. Returns an empty object when no\n   * tools were supplied (Bedrock rejects an empty `tools` array).\n   */\n  private buildToolConfig(tools: ModelCallOptions[\"tools\"]): Pick<ConverseRequest, \"toolConfig\"> {\n    const toolConfig = toBedrockToolConfig(tools);\n\n    return toolConfig ? { toolConfig } : {};\n  }\n\n  /**\n   * Translate the neutral `responseSchema` into Converse's native\n   * `outputConfig.textFormat` (JSON-schema structured output). Bedrock\n   * requires the schema as a stringified JSON document and only\n   * accepts an object root. Emitted only when the model is\n   * `structuredOutput`-capable and the schema is an object — otherwise\n   * the agent's soft system-prompt hint + client-side `validate()`\n   * carry shape (same degradation philosophy as the OpenAI adapter).\n   */\n  private buildOutputConfig(\n    responseSchema: Record<string, unknown> | undefined,\n  ): Pick<ConverseRequest, \"outputConfig\"> {\n    if (!responseSchema || !this.capabilities.structuredOutput) {\n      return {};\n    }\n\n    if (responseSchema.type !== \"object\" || typeof responseSchema.properties !== \"object\") {\n      return {};\n    }\n\n    return {\n      outputConfig: {\n        textFormat: {\n          type: \"json_schema\",\n          structure: {\n            jsonSchema: { name: \"response\", schema: JSON.stringify(responseSchema) },\n          },\n        },\n      },\n    };\n  }\n\n  /**\n   * Concatenate every `text` content block into the single neutral\n   * `content` string. `toolUse` and other block types are surfaced\n   * separately via `extractToolCalls`.\n   */\n  private extractText(blocks: ContentBlock[]): string {\n    return blocks\n      .map((block) => (\"text\" in block && typeof block.text === \"string\" ? block.text : \"\"))\n      .join(\"\");\n  }\n\n  /**\n   * Reshape Converse `toolUse` content blocks into the neutral\n   * `ModelToolCallRequest[]`. Returns `undefined` when no tools were\n   * requested so callers can branch on presence.\n   */\n  private extractToolCalls(blocks: ContentBlock[]): ModelToolCallRequest[] | undefined {\n    const toolCalls: ModelToolCallRequest[] = [];\n\n    for (const block of blocks) {\n      if (\"toolUse\" in block && block.toolUse) {\n        toolCalls.push({\n          id: block.toolUse.toolUseId ?? \"\",\n          name: block.toolUse.name ?? \"\",\n          input: (block.toolUse.input ?? {}) as Record<string, unknown>,\n        });\n      }\n    }\n\n    return toolCalls.length > 0 ? toolCalls : undefined;\n  }\n\n  /**\n   * Normalize Converse's `TokenUsage` into the neutral `Usage` shape.\n   * Bedrock supplies a pre-summed `totalTokens`; cache-read tokens are\n   * surfaced as `cachedTokens` only when non-zero.\n   */\n  private extractUsage(raw: TokenUsage | undefined): Usage {\n    if (!raw) {\n      return { input: 0, output: 0, total: 0 };\n    }\n\n    const input = raw.inputTokens ?? 0;\n    const output = raw.outputTokens ?? 0;\n    const cached = raw.cacheReadInputTokens;\n\n    return {\n      input,\n      output,\n      total: raw.totalTokens ?? input + output,\n      ...(cached && cached > 0 ? { cachedTokens: cached } : {}),\n    };\n  }\n\n  /**\n   * Wrap a thrown provider error into the typed `AIError` hierarchy\n   * and emit the standard error log line before it propagates. Shared\n   * by every catch site so the log shape stays identical.\n   */\n  private logAndWrap(thrown: unknown) {\n    const wrapped = wrapBedrockError(thrown);\n\n    this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n      code: wrapped.code,\n      context: wrapped.context,\n    });\n\n    return wrapped;\n  }\n}\n"],"mappings":"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"}

package/esm/sdk.d.mts

@@ -0,0 +1,66 @@
+import { BedrockEmbedderConfig, BedrockModelConfig, BedrockSDKConfig } from "./config.type.mjs";
+import { EmbedderContract, ModelContract, SDKAdapterContract } from "@warlock.js/ai";
+
+//#region ../../@warlock.js/ai-bedrock/src/sdk.d.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" });
+ */
+declare class BedrockSDK implements SDKAdapterContract {
+  private readonly client;
+  private readonly provider;
+  private readonly pricing?;
+  constructor(config: BedrockSDKConfig);
+  /**
+   * 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: BedrockModelConfig): ModelContract;
+  /**
+   * 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.
+   */
+  count(text: string, _model?: string): Promise<number>;
+  /**
+   * 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: BedrockEmbedderConfig): EmbedderContract;
+}
+//#endregion
+export { BedrockSDK };
+//# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../@warlock.js/ai-bedrock/src/sdk.ts"],"mappings":";;;;;;AA0CA;;;;;;;;;;;;;;;;;;;;;;;;cAAa,UAAA,YAAsB,kBAAA;EAAA,iBAChB,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,EAAQ,gBAAA;EA4CX;;;AAAgD;;;;;;;EA1BzD,KAAA,CAAM,MAAA,EAAQ,kBAAA,GAAqB,aAAA;;;;;;;EAc7B,KAAA,CAAM,IAAA,UAAc,MAAA,YAAkB,OAAA;;;;;;;;;EAY5C,QAAA,CAAS,MAAA,EAAQ,qBAAA,GAAwB,gBAAA;AAAA"}

package/esm/sdk.mjs

@@ -0,0 +1,82 @@
+import { BedrockEmbedder } from "./embedder.mjs";
+import { BedrockModel } from "./model.mjs";
+import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+import { approximateTokenCount } from "@warlock.js/ai";
+
+//#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 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 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
+export { BedrockSDK };
+//# sourceMappingURL=sdk.mjs.map

package/esm/sdk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../@warlock.js/ai-bedrock/src/sdk.ts"],"sourcesContent":["import { BedrockRuntimeClient } from \"@aws-sdk/client-bedrock-runtime\";\nimport type {\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { approximateTokenCount } from \"@warlock.js/ai\";\nimport type {\n  BedrockEmbedderConfig,\n  BedrockModelConfig,\n  BedrockSDKConfig,\n} from \"./config.type\";\nimport { BedrockEmbedder } from \"./embedder\";\nimport { BedrockModel } from \"./model\";\n\n/**\n * AWS Bedrock-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for any Bedrock-hosted model via\n * the Converse API. A single `BedrockSDK` holds one live\n * `BedrockRuntimeClient`, shared by every `ModelContract` and\n * `EmbedderContract` it produces. Construct one SDK per AWS\n * account/region and reuse it everywhere.\n *\n * **Responsibility.**\n * - Owns: a long-lived `BedrockRuntimeClient` (region, credential\n *   chain) and its lifetime. Factory for `BedrockModel` /\n *   `BedrockEmbedder` instances sharing that client.\n * - Does NOT own: anything per-call — those live in `BedrockModel` /\n *   `BedrockEmbedder` and the agent runtime.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"): the AWS client is heavy to construct and\n * designed for reuse; keeping it on `this` aligns with the\n * `new BedrockRuntimeClient(...)` upstream convention.\n *\n * @example\n * const bedrock = new BedrockSDK({ region: \"us-east-1\" });\n * const model = bedrock.model({ name: \"anthropic.claude-sonnet-4-5-20250929-v1:0\" });\n * const embedder = bedrock.embedder({ name: \"amazon.titan-embed-text-v2:0\" });\n */\nexport class BedrockSDK implements SDKAdapterContract {\n  private readonly client: BedrockRuntimeClient;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: BedrockSDKConfig) {\n    const { provider, pricing, ...clientConfig } = config;\n\n    this.client = new BedrockRuntimeClient(clientConfig);\n    this.provider = provider ?? \"bedrock\";\n    this.pricing = pricing;\n  }\n\n  /**\n   * Build a `BedrockModel` bound to this SDK's client. Each call\n   * returns a fresh instance; all instances share the underlying AWS\n   * client so connection pools, credential refresh, and retry config\n   * stay unified. The SDK's `provider` label is forwarded.\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise the\n   * SDK-level registry entry keyed by `config.name`; otherwise\n   * `undefined` (no cost computed).\n   */\n  public model(config: BedrockModelConfig): ModelContract {\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: BedrockModelConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    return new BedrockModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Rough token-count estimate. Uses the character-heuristic\n   * (`approximateTokenCount`) from the core package — Bedrock has no\n   * offline tokenizer and the per-model tokenizers differ; good enough\n   * for budgeting and quota guards, not for billing.\n   */\n  public async count(text: string, _model?: string): Promise<number> {\n    return approximateTokenCount(text);\n  }\n\n  /**\n   * Build a `BedrockEmbedder` (Amazon Titan Text Embeddings) bound to\n   * this SDK's client.\n   *\n   * @example\n   * const embedder = bedrock.embedder({ name: \"amazon.titan-embed-text-v2:0\" });\n   * const { vector } = await embedder.embed(\"Hello world\");\n   */\n  public embedder(config: BedrockEmbedderConfig): EmbedderContract {\n    return new BedrockEmbedder(this.client, config, this.provider);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,aAAb,MAAsD;CAKpD,AAAO,YAAY,QAA0B;EAC3C,MAAM,EAAE,UAAU,SAAS,GAAG,iBAAiB;EAE/C,KAAK,SAAS,IAAI,qBAAqB,YAAY;EACnD,KAAK,WAAW,YAAY;EAC5B,KAAK,UAAU;CACjB;;;;;;;;;;;CAYA,AAAO,MAAM,QAA2C;EACtD,MAAM,kBAAkB,OAAO,WAAW,KAAK,UAAU,OAAO;EAChE,MAAM,iBACJ,oBAAoB,OAAO,UAAU,SAAS;GAAE,GAAG;GAAQ,SAAS;EAAgB;EAEtF,OAAO,IAAI,aAAa,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;CACpE;;;;;;;CAQA,MAAa,MAAM,MAAc,QAAkC;EACjE,OAAO,sBAAsB,IAAI;CACnC;;;;;;;;;CAUA,AAAO,SAAS,QAAiD;EAC/D,OAAO,IAAI,gBAAgB,KAAK,QAAQ,QAAQ,KAAK,QAAQ;CAC/D;AACF"}

package/esm/utils/index.mjs

@@ -0,0 +1,6 @@
+import { mapStopReason } from "./map-stop-reason.mjs";
+import { toBedrockMessages } from "./to-bedrock-messages.mjs";
+import { toBedrockToolConfig } from "./to-bedrock-tools.mjs";
+import { wrapBedrockError } from "./wrap-bedrock-error.mjs";
+
+export {  };

package/esm/utils/map-stop-reason.mjs

@@ -0,0 +1,31 @@
+//#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
+export { mapStopReason };
+//# sourceMappingURL=map-stop-reason.mjs.map

package/esm/utils/map-stop-reason.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-stop-reason.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-bedrock/src/utils/map-stop-reason.ts"],"sourcesContent":["import type { FinishReason } from \"@warlock.js/ai\";\n\nconst stopReasonMap: Record<string, FinishReason> = {\n  end_turn: \"stop\",\n  stop_sequence: \"stop\",\n  max_tokens: \"length\",\n  tool_use: \"tool_calls\",\n};\n\n/**\n * Map Bedrock Converse's `stopReason` to the normalized `FinishReason`\n * union.\n *\n * `end_turn` / `stop_sequence` are natural stops. `max_tokens` maps to\n * `length`. `tool_use` maps to `tool_calls`. Everything else —\n * `content_filtered`, `guardrail_intervened`, `malformed_tool_use`,\n * `malformed_model_output`, `model_context_window_exceeded`, `null`,\n * or any future value — falls through to `\"error\"`: none produced a\n * clean terminal answer, so the agent must not treat them as success.\n *\n * @example\n * mapStopReason(\"end_turn\");              // \"stop\"\n * mapStopReason(\"tool_use\");              // \"tool_calls\"\n * mapStopReason(\"guardrail_intervened\");  // \"error\"\n * mapStopReason(undefined);               // \"error\"\n */\nexport function mapStopReason(raw: string | null | undefined): FinishReason {\n  return stopReasonMap[raw ?? \"\"] ?? \"error\";\n}\n"],"mappings":";AAEA,MAAM,gBAA8C;CAClD,UAAU;CACV,eAAe;CACf,YAAY;CACZ,UAAU;AACZ;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,cAAc,KAA8C;CAC1E,OAAO,cAAc,OAAO,OAAO;AACrC"}

package/esm/utils/to-bedrock-messages.mjs

@@ -0,0 +1,111 @@
+import { InvalidRequestError } from "@warlock.js/ai";
+
+//#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 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 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
+export { toBedrockMessages };
+//# sourceMappingURL=to-bedrock-messages.mjs.map

package/esm/utils/to-bedrock-messages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-bedrock-messages.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-bedrock/src/utils/to-bedrock-messages.ts"],"sourcesContent":["import { InvalidRequestError, type ContentPart, type Message } from \"@warlock.js/ai\";\nimport type {\n  ContentBlock,\n  ImageFormat,\n  Message as BedrockMessage,\n  SystemContentBlock,\n} from \"@aws-sdk/client-bedrock-runtime\";\n\n/**\n * Result of splitting a vendor-neutral `Message[]` for the Bedrock\n * Converse API: system prompts hoist to a separate `SystemContentBlock[]`\n * (Converse has no `\"system\"` role inside `messages`), and the\n * remaining turns map to Bedrock `Message[]`.\n */\nexport type BedrockMessages = {\n  system: SystemContentBlock[] | undefined;\n  messages: BedrockMessage[];\n};\n\nconst MEDIA_TYPE_TO_FORMAT: Record<string, ImageFormat> = {\n  \"image/jpeg\": \"jpeg\",\n  \"image/png\": \"png\",\n  \"image/gif\": \"gif\",\n  \"image/webp\": \"webp\",\n};\n\n/**\n * Convert vendor-neutral `Message[]` into Bedrock Converse's request\n * shape.\n *\n * Converse differs from the OpenAI Chat protocol in three ways this\n * function absorbs:\n *\n * 1. **No `system` role.** System messages become a separate\n *    `SystemContentBlock[]` (one `{ text }` block each).\n * 2. **Tool results are `user` turns.** A neutral `tool` message\n *    becomes a `user` message carrying a single `toolResult` block.\n * 3. **Tool calls are `toolUse` content blocks.** An assistant message\n *    with `toolCalls` becomes an `assistant` message: an optional\n *    leading `text` block followed by one `toolUse` block per call.\n *\n * @example\n * const { system, messages } = toBedrockMessages([\n *   { role: \"system\", content: \"Be concise.\" },\n *   { role: \"user\", content: \"Hi\" },\n * ]);\n */\nexport function toBedrockMessages(messages: Message[]): BedrockMessages {\n  const system: SystemContentBlock[] = [];\n  const mapped: BedrockMessage[] = [];\n\n  for (const message of messages) {\n    if (message.role === \"system\") {\n      system.push({ text: stringifyContent(message.content) });\n\n      continue;\n    }\n\n    if (message.role === \"tool\") {\n      mapped.push({\n        role: \"user\",\n        content: [\n          {\n            toolResult: {\n              toolUseId: message.toolCallId ?? \"\",\n              content: [{ text: stringifyContent(message.content) }],\n            },\n          },\n        ],\n      });\n\n      continue;\n    }\n\n    if (message.role === \"assistant\" && message.toolCalls && message.toolCalls.length > 0) {\n      const blocks: ContentBlock[] = [];\n      const text = stringifyContent(message.content);\n\n      if (text) {\n        blocks.push({ text });\n      }\n\n      for (const toolCall of message.toolCalls) {\n        blocks.push({\n          toolUse: {\n            toolUseId: toolCall.id,\n            name: toolCall.name,\n            input: toolCall.input ?? {},\n          },\n        } as ContentBlock);\n      }\n\n      mapped.push({ role: \"assistant\", content: blocks });\n\n      continue;\n    }\n\n    if (message.role === \"user\" && Array.isArray(message.content)) {\n      mapped.push({\n        role: \"user\",\n        content: message.content.map(toBedrockContentBlock),\n      });\n\n      continue;\n    }\n\n    mapped.push({\n      role: message.role === \"assistant\" ? \"assistant\" : \"user\",\n      content: [{ text: stringifyContent(message.content) }],\n    });\n  }\n\n  return {\n    system: system.length > 0 ? system : undefined,\n    messages: mapped,\n  };\n}\n\n/**\n * Multipart content is only meaningful on user messages — for any other\n * role collapse a `ContentPart[]` to its concatenated text. Plain\n * strings pass through unchanged.\n */\nfunction stringifyContent(content: string | ContentPart[]): string {\n  if (typeof content === \"string\") {\n    return content;\n  }\n\n  return content\n    .filter((part): part is { type: \"text\"; text: string } => part.type === \"text\")\n    .map((part) => part.text)\n    .join(\"\");\n}\n\n/**\n * Map a resolved `ContentPart` to a Bedrock `ContentBlock`. Bedrock's\n * `ImageSource` only accepts raw bytes or an S3 location — there is no\n * remote-URL source. A neutral `{ url }` image therefore cannot be\n * sent and surfaces a typed `InvalidRequestError` upfront rather than\n * a downstream Bedrock validation fault. The agent has already\n * resolved attachments, so this never fetches or reads anything.\n */\nfunction toBedrockContentBlock(part: ContentPart): ContentBlock {\n  if (part.type === \"text\") {\n    return { text: part.text };\n  }\n\n  if (\"url\" in part.source) {\n    throw new InvalidRequestError(\n      \"Bedrock Converse does not support remote-URL image sources; supply base64 image bytes instead.\",\n    );\n  }\n\n  const format = MEDIA_TYPE_TO_FORMAT[part.source.mediaType];\n\n  if (!format) {\n    throw new InvalidRequestError(\n      `Unsupported image media type for Bedrock: \"${part.source.mediaType}\" (expected image/jpeg, image/png, image/gif, or image/webp).`,\n    );\n  }\n\n  return {\n    image: {\n      format,\n      source: { bytes: Buffer.from(part.source.base64, \"base64\") },\n    },\n  };\n}\n"],"mappings":";;;AAmBA,MAAM,uBAAoD;CACxD,cAAc;CACd,aAAa;CACb,aAAa;CACb,cAAc;AAChB;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,kBAAkB,UAAsC;CACtE,MAAM,SAA+B,CAAC;CACtC,MAAM,SAA2B,CAAC;CAElC,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,QAAQ,SAAS,UAAU;GAC7B,OAAO,KAAK,EAAE,MAAM,iBAAiB,QAAQ,OAAO,EAAE,CAAC;GAEvD;EACF;EAEA,IAAI,QAAQ,SAAS,QAAQ;GAC3B,OAAO,KAAK;IACV,MAAM;IACN,SAAS,CACP,EACE,YAAY;KACV,WAAW,QAAQ,cAAc;KACjC,SAAS,CAAC,EAAE,MAAM,iBAAiB,QAAQ,OAAO,EAAE,CAAC;IACvD,EACF,CACF;GACF,CAAC;GAED;EACF;EAEA,IAAI,QAAQ,SAAS,eAAe,QAAQ,aAAa,QAAQ,UAAU,SAAS,GAAG;GACrF,MAAM,SAAyB,CAAC;GAChC,MAAM,OAAO,iBAAiB,QAAQ,OAAO;GAE7C,IAAI,MACF,OAAO,KAAK,EAAE,KAAK,CAAC;GAGtB,KAAK,MAAM,YAAY,QAAQ,WAC7B,OAAO,KAAK,EACV,SAAS;IACP,WAAW,SAAS;IACpB,MAAM,SAAS;IACf,OAAO,SAAS,SAAS,CAAC;GAC5B,EACF,CAAiB;GAGnB,OAAO,KAAK;IAAE,MAAM;IAAa,SAAS;GAAO,CAAC;GAElD;EACF;EAEA,IAAI,QAAQ,SAAS,UAAU,MAAM,QAAQ,QAAQ,OAAO,GAAG;GAC7D,OAAO,KAAK;IACV,MAAM;IACN,SAAS,QAAQ,QAAQ,IAAI,qBAAqB;GACpD,CAAC;GAED;EACF;EAEA,OAAO,KAAK;GACV,MAAM,QAAQ,SAAS,cAAc,cAAc;GACnD,SAAS,CAAC,EAAE,MAAM,iBAAiB,QAAQ,OAAO,EAAE,CAAC;EACvD,CAAC;CACH;CAEA,OAAO;EACL,QAAQ,OAAO,SAAS,IAAI,SAAS;EACrC,UAAU;CACZ;AACF;;;;;;AAOA,SAAS,iBAAiB,SAAyC;CACjE,IAAI,OAAO,YAAY,UACrB,OAAO;CAGT,OAAO,QACJ,QAAQ,SAAiD,KAAK,SAAS,MAAM,EAC7E,KAAK,SAAS,KAAK,IAAI,EACvB,KAAK,EAAE;AACZ;;;;;;;;;AAUA,SAAS,sBAAsB,MAAiC;CAC9D,IAAI,KAAK,SAAS,QAChB,OAAO,EAAE,MAAM,KAAK,KAAK;CAG3B,IAAI,SAAS,KAAK,QAChB,MAAM,IAAI,oBACR,gGACF;CAGF,MAAM,SAAS,qBAAqB,KAAK,OAAO;CAEhD,IAAI,CAAC,QACH,MAAM,IAAI,oBACR,8CAA8C,KAAK,OAAO,UAAU,8DACtE;CAGF,OAAO,EACL,OAAO;EACL;EACA,QAAQ,EAAE,OAAO,OAAO,KAAK,KAAK,OAAO,QAAQ,QAAQ,EAAE;CAC7D,EACF;AACF"}