@draht/ai 2026.5.12 → 2026.6.11

package/dist/providers/amazon-bedrock.js

@@ -1,10 +1,13 @@
 import { BedrockRuntimeClient, BedrockRuntimeServiceException, StopReason as BedrockStopReason, CachePointType, CacheTTL, ConversationRole, ConverseStreamCommand, ImageFormat, ToolResultStatus, } from "@aws-sdk/client-bedrock-runtime";
-import { calculateCost, supportsMax } from "../models.js";
+import { NodeHttpHandler } from "@smithy/node-http-handler";
+import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
+import { createHttpProxyAgentsForTarget } from "../utils/node-http-proxy.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampReasoning } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
+const EMPTY_TEXT_PLACEHOLDER = "<empty>";
 export const streamBedrock = (model, context, options = {}) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -29,16 +32,35 @@ export const streamBedrock = (model, context, options = {}) => {
         const config = {
             profile: options.profile,
         };
+        const configuredRegion = getConfiguredBedrockRegion(options);
+        const hasConfiguredProfile = hasConfiguredBedrockProfile();
+        const endpointRegion = getStandardBedrockEndpointRegion(model.baseUrl);
+        const useExplicitEndpoint = shouldUseExplicitBedrockEndpoint(model.baseUrl, configuredRegion, hasConfiguredProfile);
+        // Only pin standard AWS Bedrock runtime endpoints when no region/profile is configured.
+        // This preserves custom endpoints (VPC/proxy) from #3402 without forcing built-in
+        // catalog defaults such as us-east-1 to override AWS_REGION/AWS_PROFILE.
+        if (useExplicitEndpoint) {
+            config.endpoint = model.baseUrl;
+        }
+        // Resolve bearer token for Bedrock API key auth.
+        const bearerToken = options.bearerToken || process.env.AWS_BEARER_TOKEN_BEDROCK || undefined;
+        const useBearerToken = bearerToken !== undefined && process.env.AWS_BEDROCK_SKIP_AUTH !== "1";
         // in Node.js/Bun environment only
         if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
-            // Region resolution: explicit option > env vars > SDK default chain.
-            // When AWS_PROFILE is set, we leave region undefined so the SDK can
-            // resovle it from aws profile configs. Otherwise fall back to us-east-1.
-            const explicitRegion = options.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
-            if (explicitRegion) {
-                config.region = explicitRegion;
+            // Region resolution: ARN-embedded > explicit option > env vars > SDK default chain.
+            // When the model ID is an inference profile ARN, extract the region from it.
+            // This avoids conflicts with AWS_REGION set for other services.
+            const arnRegionMatch = model.id.match(/^arn:aws(?:-[a-z0-9-]+)?:bedrock:([a-z0-9-]+):/);
+            if (arnRegionMatch) {
+                config.region = arnRegionMatch[1];
+            }
+            else if (configuredRegion) {
+                config.region = configuredRegion;
             }
-            else if (!process.env.AWS_PROFILE) {
+            else if (endpointRegion && useExplicitEndpoint) {
+                config.region = endpointRegion;
+            }
+            else if (!hasConfiguredProfile) {
                 config.region = "us-east-1";
             }
             // Support proxies that don't need authentication
@@ -48,42 +70,43 @@ export const streamBedrock = (model, context, options = {}) => {
                     secretAccessKey: "dummy-secret-key",
                 };
             }
-            if (process.env.HTTP_PROXY ||
-                process.env.HTTPS_PROXY ||
-                process.env.NO_PROXY ||
-                process.env.http_proxy ||
-                process.env.https_proxy ||
-                process.env.no_proxy) {
-                const nodeHttpHandler = await import("@smithy/node-http-handler");
-                const proxyAgent = await import("proxy-agent");
-                const agent = new proxyAgent.ProxyAgent();
+            const proxyAgents = createHttpProxyAgentsForTarget(model.baseUrl);
+            if (proxyAgents) {
                 // Bedrock runtime uses NodeHttp2Handler by default since v3.798.0, which is based
                 // on `http2` module and has no support for http agent.
-                // Use NodeHttpHandler to support http agent.
-                config.requestHandler = new nodeHttpHandler.NodeHttpHandler({
-                    httpAgent: agent,
-                    httpsAgent: agent,
-                });
+                // Use NodeHttpHandler to support HTTP(S) proxy agents.
+                config.requestHandler = new NodeHttpHandler(proxyAgents);
             }
             else if (process.env.AWS_BEDROCK_FORCE_HTTP1 === "1") {
                 // Some custom endpoints require HTTP/1.1 instead of HTTP/2
-                const nodeHttpHandler = await import("@smithy/node-http-handler");
-                config.requestHandler = new nodeHttpHandler.NodeHttpHandler();
+                config.requestHandler = new NodeHttpHandler();
             }
         }
         else {
             // Non-Node environment (browser): fall back to us-east-1 since
             // there's no config file resolution available.
-            config.region = options.region || "us-east-1";
+            config.region =
+                configuredRegion || (endpointRegion && useExplicitEndpoint ? endpointRegion : undefined) || "us-east-1";
+        }
+        if (useBearerToken) {
+            config.token = { token: bearerToken };
+            config.authSchemePreference = ["httpBearerAuth"];
         }
         try {
             const client = new BedrockRuntimeClient(config);
+            if (options.headers && Object.keys(options.headers).length > 0) {
+                addCustomHeadersMiddleware(client, options.headers);
+            }
             const cacheRetention = resolveCacheRetention(options.cacheRetention);
+            const inferenceMaxTokens = options.maxTokens ?? (isAnthropicClaudeModel(model) ? model.maxTokens : undefined);
             let commandInput = {
                 modelId: model.id,
                 messages: convertMessages(context, model, cacheRetention),
                 system: buildSystemPrompt(context.systemPrompt, model, cacheRetention),
-                inferenceConfig: { maxTokens: options.maxTokens, temperature: options.temperature },
+                inferenceConfig: {
+                    ...(inferenceMaxTokens !== undefined && { maxTokens: inferenceMaxTokens }),
+                    ...(options.temperature !== undefined && { temperature: options.temperature }),
+                },
                 toolConfig: convertToolConfig(context.tools, options.toolChoice),
                 additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
                 ...(options.requestMetadata !== undefined && { requestMetadata: options.requestMetadata }),
@@ -94,6 +117,13 @@ export const streamBedrock = (model, context, options = {}) => {
             }
             const command = new ConverseStreamCommand(commandInput);
             const response = await client.send(command, { abortSignal: options.signal });
+            if (response.$metadata.httpStatusCode !== undefined) {
+                const responseHeaders = {};
+                if (response.$metadata.requestId) {
+                    responseHeaders["x-amzn-requestid"] = response.$metadata.requestId;
+                }
+                await options?.onResponse?.({ status: response.$metadata.httpStatusCode, headers: responseHeaders }, model);
+            }
             for await (const item of response.stream) {
                 if (item.messageStart) {
                     if (item.messageStart.role !== ConversationRole.ASSISTANT) {
@@ -144,6 +174,7 @@ export const streamBedrock = (model, context, options = {}) => {
         catch (error) {
             for (const block of output.content) {
                 delete block.index;
+                // partialJson is only a streaming scratch buffer; never persist it.
                 delete block.partialJson;
             }
             output.stopReason = options.signal?.aborted ? "aborted" : "error";
@@ -167,6 +198,12 @@ const BEDROCK_ERROR_PREFIXES = {
     ThrottlingException: "Throttling error",
     ServiceUnavailableException: "Service unavailable",
 };
+/**
+ * Some models reject the account/profile's configured Bedrock data retention mode
+ * (e.g. "data retention mode 'default' is not available for this model"). Point
+ * users at the AWS docs explaining how to configure a supported mode.
+ */
+const BEDROCK_DATA_RETENTION_DOCS_URL = "https://docs.aws.amazon.com/bedrock/latest/userguide/data-retention.html";
 /**
  * Format a Bedrock error with a human-readable prefix.
  * AWS SDK exceptions (both from `client.send()` and from stream event items)
@@ -176,26 +213,64 @@ const BEDROCK_ERROR_PREFIXES = {
  */
 function formatBedrockError(error) {
     const message = error instanceof Error ? error.message : JSON.stringify(error);
+    const dataRetentionHint = /data retention mode/i.test(message)
+        ? ` See ${BEDROCK_DATA_RETENTION_DOCS_URL} for supported data retention modes.`
+        : "";
     if (error instanceof BedrockRuntimeServiceException) {
         const prefix = BEDROCK_ERROR_PREFIXES[error.name] ?? error.name;
-        return `${prefix}: ${message}`;
+        return `${prefix}: ${message}${dataRetentionHint}`;
     }
-    return message;
+    return `${message}${dataRetentionHint}`;
+}
+/**
+ * Header keys that must never be overwritten by caller-supplied headers.
+ * `host` and `x-amz-*` participate in the SigV4 canonical request; `authorization`
+ * is owned by SigV4 or the bearer-token path (config.token + authSchemePreference).
+ * Compared case-insensitively (caller key is lower-cased before lookup).
+ */
+const RESERVED_HEADER_EXACT = new Set(["authorization", "host"]);
+function isReservedHeader(key) {
+    const lower = key.toLowerCase();
+    return lower.startsWith("x-amz-") || RESERVED_HEADER_EXACT.has(lower);
+}
+/**
+ * Attach caller-supplied headers to the outgoing Bedrock request via a Smithy
+ * `build`-step middleware. The `build` step runs after request serialisation but
+ * before SigV4 signing, so injected headers are covered by the signature. Reserved
+ * SigV4 / auth headers (`x-amz-*`, `authorization`, `host`) are silently skipped;
+ * all other caller headers override any existing same-named header on the request.
+ */
+function addCustomHeadersMiddleware(client, headers) {
+    const middleware = (next) => async (args) => {
+        const request = args.request;
+        if (request && typeof request === "object" && "headers" in request) {
+            const requestHeaders = request.headers;
+            for (const [key, value] of Object.entries(headers)) {
+                if (!isReservedHeader(key)) {
+                    requestHeaders[key] = value;
+                }
+            }
+        }
+        return next(args);
+    };
+    client.middlewareStack.add(middleware, { step: "build", name: "pi-ai-custom-headers", priority: "low" });
 }
 export const streamSimpleBedrock = (model, context, options) => {
     const base = buildBaseOptions(model, options, undefined);
     if (!options?.reasoning) {
         return streamBedrock(model, context, { ...base, reasoning: undefined });
     }
-    if (model.id.includes("anthropic.claude") || model.id.includes("anthropic/claude")) {
-        if (supportsAdaptiveThinking(model.id)) {
+    if (isAnthropicClaudeModel(model)) {
+        if (supportsAdaptiveThinking(model.id, model.name)) {
             return streamBedrock(model, context, {
                 ...base,
                 reasoning: options.reasoning,
                 thinkingBudgets: options.thinkingBudgets,
             });
         }
-        const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
+        // Undefined means the caller did not request an output cap; let the helper use the model cap.
+        // Do not coerce to 0 here, or the thinking budget would become the entire maxTokens value.
+        const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, options.reasoning, options.thinkingBudgets);
         return streamBedrock(model, context, {
             ...base,
             maxTokens: adjusted.maxTokens,
@@ -304,22 +379,43 @@ function handleContentBlockStop(event, blocks, output, stream) {
             break;
         case "toolCall":
             block.arguments = parseStreamingJson(block.partialJson);
+            // Finalize in-place and strip the scratch buffer so replay only
+            // carries parsed arguments.
             delete block.partialJson;
             stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: output });
             break;
     }
 }
 /**
- * Check if the model supports adaptive thinking (Opus 4.6 and Sonnet 4.6).
+ * Check if the model supports adaptive thinking (Opus 4.6+, Sonnet 4.6).
+ * Checks both model ID and model name to support application inference profiles
+ * whose ARNs don't contain the model name.
  */
-function supportsAdaptiveThinking(modelId) {
-    return (modelId.includes("opus-4-6") ||
-        modelId.includes("opus-4.6") ||
-        modelId.includes("sonnet-4-6") ||
-        modelId.includes("sonnet-4.6"));
+function getModelMatchCandidates(modelId, modelName) {
+    const values = modelName ? [modelId, modelName] : [modelId];
+    return values.flatMap((value) => {
+        const lower = value.toLowerCase();
+        return [lower, lower.replace(/[\s_.:]+/g, "-")];
+    });
+}
+function supportsAdaptiveThinking(modelId, modelName) {
+    const candidates = getModelMatchCandidates(modelId, modelName);
+    return candidates.some((s) => s.includes("opus-4-6") ||
+        s.includes("opus-4-7") ||
+        s.includes("opus-4-8") ||
+        s.includes("sonnet-4-6") ||
+        s.includes("fable-5"));
 }
-function mapThinkingLevelToEffort(level, modelId) {
-    const supportsMaxEffort = supportsMax({ id: modelId });
+function supportsNativeXhighEffort(model) {
+    const candidates = getModelMatchCandidates(model.id, model.name);
+    return candidates.some((s) => s.includes("opus-4-7") || s.includes("opus-4-8") || s.includes("fable-5"));
+}
+function mapThinkingLevelToEffort(model, level) {
+    if (level === "xhigh" && supportsNativeXhighEffort(model))
+        return "xhigh";
+    const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
+    if (typeof mapped === "string")
+        return mapped;
     switch (level) {
         case "minimal":
         case "low":
@@ -328,10 +424,6 @@ function mapThinkingLevelToEffort(level, modelId) {
             return "medium";
         case "high":
             return "high";
-        case "xhigh":
-            return supportsMaxEffort ? "max" : "high";
-        case "max":
-            return supportsMaxEffort ? "max" : "high";
         default:
             return "high";
     }
@@ -349,6 +441,20 @@ function resolveCacheRetention(cacheRetention) {
     }
     return "short";
 }
+/**
+ * Check if the model is an Anthropic Claude model on Bedrock.
+ * Checks both model ID and model name to support application inference profiles
+ * whose ARNs don't contain the model name.
+ */
+function isAnthropicClaudeModel(model) {
+    const id = model.id.toLowerCase();
+    const name = model.name?.toLowerCase() ?? "";
+    return (id.includes("anthropic.claude") ||
+        id.includes("anthropic/claude") ||
+        name.includes("anthropic.claude") ||
+        name.includes("anthropic/claude") ||
+        name.includes("claude"));
+}
 /**
  * Check if the model supports prompt caching.
  * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, Claude 4.x models
@@ -357,12 +463,14 @@ function resolveCacheRetention(cacheRetention) {
  * contains the model name, so we can decide locally.
  *
  * For application inference profiles (whose ARNs don't contain the model name),
- * set AWS_BEDROCK_FORCE_CACHE=1 to enable cache points.  Amazon Nova models
- * have automatic caching and don't need explicit cache points.
+ * also checks model.name which is user-controlled via models.json or registerProvider.
+ * As a last resort, set AWS_BEDROCK_FORCE_CACHE=1 to enable cache points.
+ * Amazon Nova models have automatic caching and don't need explicit cache points.
  */
 function supportsPromptCaching(model) {
-    const id = model.id.toLowerCase();
-    if (!id.includes("claude")) {
+    const candidates = getModelMatchCandidates(model.id, model.name);
+    const hasClaudeRef = candidates.some((s) => s.includes("claude"));
+    if (!hasClaudeRef) {
         // Application inference profiles don't contain the model name in the ARN.
         // Allow users to force cache points via environment variable.
         if (typeof process !== "undefined" && process.env.AWS_BEDROCK_FORCE_CACHE === "1")
@@ -370,13 +478,13 @@ function supportsPromptCaching(model) {
         return false;
     }
     // Claude 4.x models (opus-4, sonnet-4, haiku-4)
-    if (id.includes("-4-") || id.includes("-4."))
+    if (candidates.some((s) => s.includes("-4-")))
         return true;
     // Claude 3.7 Sonnet
-    if (id.includes("claude-3-7-sonnet"))
+    if (candidates.some((s) => s.includes("claude-3-7-sonnet")))
         return true;
     // Claude 3.5 Haiku
-    if (id.includes("claude-3-5-haiku"))
+    if (candidates.some((s) => s.includes("claude-3-5-haiku")))
         return true;
     return false;
 }
@@ -385,10 +493,11 @@ function supportsPromptCaching(model) {
  * Only Anthropic Claude models support the signature field.
  * Other models (OpenAI, Qwen, Minimax, Moonshot, etc.) reject it with:
  * "This model doesn't support the reasoningContent.reasoningText.signature field"
+ *
+ * Checks both model ID and model name to support application inference profiles.
  */
 function supportsThinkingSignature(model) {
-    const id = model.id.toLowerCase();
-    return id.includes("anthropic.claude") || id.includes("anthropic/claude");
+    return isAnthropicClaudeModel(model);
 }
 function buildSystemPrompt(systemPrompt, model, cacheRetention) {
     if (!systemPrompt)
@@ -406,29 +515,65 @@ function normalizeToolCallId(id) {
     const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
     return sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
 }
+function createNonBlankTextBlock(text) {
+    const sanitized = sanitizeSurrogates(text);
+    return sanitized.trim().length === 0 ? undefined : { text: sanitized };
+}
+function createRequiredTextBlock(text) {
+    return createNonBlankTextBlock(text) ?? { text: EMPTY_TEXT_PLACEHOLDER };
+}
+function convertToolResultContent(content) {
+    const result = [];
+    for (const c of content) {
+        if (c.type === "image") {
+            result.push({ image: createImageBlock(c.mimeType, c.data) });
+        }
+        else {
+            const textBlock = createNonBlankTextBlock(c.text);
+            if (textBlock)
+                result.push(textBlock);
+        }
+    }
+    if (result.length === 0)
+        result.push({ text: EMPTY_TEXT_PLACEHOLDER });
+    return result;
+}
 function convertMessages(context, model, cacheRetention) {
     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 "user":
+            case "user": {
+                const content = [];
+                if (typeof m.content === "string") {
+                    content.push(createRequiredTextBlock(m.content));
+                }
+                else {
+                    for (const c of m.content) {
+                        switch (c.type) {
+                            case "text": {
+                                const textBlock = createNonBlankTextBlock(c.text);
+                                if (textBlock)
+                                    content.push(textBlock);
+                                break;
+                            }
+                            case "image":
+                                content.push({ image: createImageBlock(c.mimeType, c.data) });
+                                break;
+                            default:
+                                continue;
+                        }
+                    }
+                    if (content.length === 0)
+                        content.push({ text: EMPTY_TEXT_PLACEHOLDER });
+                }
                 result.push({
                     role: ConversationRole.USER,
-                    content: typeof m.content === "string"
-                        ? [{ text: sanitizeSurrogates(m.content) }]
-                        : m.content.map((c) => {
-                            switch (c.type) {
-                                case "text":
-                                    return { text: sanitizeSurrogates(c.text) };
-                                case "image":
-                                    return { image: createImageBlock(c.mimeType, c.data) };
-                                default:
-                                    throw new Error("Unknown user content type");
-                            }
-                        }),
+                    content,
                 });
                 break;
+            }
             case "assistant": {
                 // Skip assistant messages with empty content (e.g., from aborted requests)
                 // Bedrock rejects messages with empty content arrays
@@ -438,20 +583,23 @@ function convertMessages(context, model, cacheRetention) {
                 const contentBlocks = [];
                 for (const c of m.content) {
                     switch (c.type) {
-                        case "text":
+                        case "text": {
                             // Skip empty text blocks
-                            if (c.text.trim().length === 0)
+                            const textBlock = createNonBlankTextBlock(c.text);
+                            if (!textBlock)
                                 continue;
-                            contentBlocks.push({ text: sanitizeSurrogates(c.text) });
+                            contentBlocks.push(textBlock);
                             break;
+                        }
                         case "toolCall":
                             contentBlocks.push({
                                 toolUse: { toolUseId: c.id, name: c.name, input: c.arguments },
                             });
                             break;
-                        case "thinking":
+                        case "thinking": {
                             // Skip empty thinking blocks
-                            if (c.thinking.trim().length === 0)
+                            const thinking = sanitizeSurrogates(c.thinking);
+                            if (thinking.trim().length === 0)
                                 continue;
                             // Only Anthropic models support the signature field in reasoningText.
                             // For other models, we omit the signature to avoid errors like:
@@ -461,13 +609,13 @@ function convertMessages(context, model, cacheRetention) {
                                 // persisted message lacks a signature, Bedrock rejects the replayed
                                 // reasoning block. Fall back to plain text, matching Anthropic.
                                 if (!c.thinkingSignature || c.thinkingSignature.trim().length === 0) {
-                                    contentBlocks.push({ text: sanitizeSurrogates(c.thinking) });
+                                    contentBlocks.push({ text: thinking });
                                 }
                                 else {
                                     contentBlocks.push({
                                         reasoningContent: {
                                             reasoningText: {
-                                                text: sanitizeSurrogates(c.thinking),
+                                                text: thinking,
                                                 signature: c.thinkingSignature,
                                             },
                                         },
@@ -477,13 +625,14 @@ function convertMessages(context, model, cacheRetention) {
                             else {
                                 contentBlocks.push({
                                     reasoningContent: {
-                                        reasoningText: { text: sanitizeSurrogates(c.thinking) },
+                                        reasoningText: { text: thinking },
                                     },
                                 });
                             }
                             break;
+                        }
                         default:
-                            throw new Error("Unknown assistant content type");
+                            continue;
                     }
                 }
                 // Skip if all content blocks were filtered out
@@ -504,9 +653,7 @@ function convertMessages(context, model, cacheRetention) {
                 toolResults.push({
                     toolResult: {
                         toolUseId: m.toolCallId,
-                        content: m.content.map((c) => c.type === "image"
-                            ? { image: createImageBlock(c.mimeType, c.data) }
-                            : { text: sanitizeSurrogates(c.text) }),
+                        content: convertToolResultContent(m.content),
                         status: m.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
                     },
                 });
@@ -517,9 +664,7 @@ function convertMessages(context, model, cacheRetention) {
                     toolResults.push({
                         toolResult: {
                             toolUseId: nextMsg.toolCallId,
-                            content: nextMsg.content.map((c) => c.type === "image"
-                                ? { image: createImageBlock(c.mimeType, c.data) }
-                                : { text: sanitizeSurrogates(c.text) }),
+                            content: convertToolResultContent(nextMsg.content),
                             status: nextMsg.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
                         },
                     });
@@ -534,7 +679,7 @@ function convertMessages(context, model, cacheRetention) {
                 break;
             }
             default:
-                throw new Error("Unknown message role");
+                continue;
         }
     }
     // Add cache point to the last user message for supported Claude models when caching is enabled
@@ -590,15 +735,58 @@ function mapStopReason(reason) {
             return "error";
     }
 }
+function getConfiguredBedrockRegion(options) {
+    if (typeof process === "undefined") {
+        return options.region;
+    }
+    return options.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || undefined;
+}
+function hasConfiguredBedrockProfile() {
+    if (typeof process === "undefined") {
+        return false;
+    }
+    return Boolean(process.env.AWS_PROFILE);
+}
+function getStandardBedrockEndpointRegion(baseUrl) {
+    if (!baseUrl) {
+        return undefined;
+    }
+    try {
+        const { hostname } = new URL(baseUrl);
+        const match = hostname.toLowerCase().match(/^bedrock-runtime(?:-fips)?\.([a-z0-9-]+)\.amazonaws\.com(?:\.cn)?$/);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldUseExplicitBedrockEndpoint(baseUrl, configuredRegion, hasConfiguredProfile) {
+    const endpointRegion = getStandardBedrockEndpointRegion(baseUrl);
+    if (!endpointRegion) {
+        return true;
+    }
+    return !configuredRegion && !hasConfiguredProfile;
+}
+function isGovCloudBedrockTarget(model, options) {
+    const region = getConfiguredBedrockRegion(options);
+    if (region?.toLowerCase().startsWith("us-gov-")) {
+        return true;
+    }
+    const modelId = model.id.toLowerCase();
+    return modelId.startsWith("us-gov.") || modelId.startsWith("arn:aws-us-gov:");
+}
 function buildAdditionalModelRequestFields(model, options) {
     if (!options.reasoning || !model.reasoning) {
         return undefined;
     }
-    if (model.id.includes("anthropic.claude") || model.id.includes("anthropic/claude")) {
-        const result = supportsAdaptiveThinking(model.id)
+    if (isAnthropicClaudeModel(model)) {
+        // GovCloud Bedrock currently rejects the Claude thinking.display field.
+        // Omit it there until the GovCloud Converse schema catches up.
+        const display = isGovCloudBedrockTarget(model, options) ? undefined : (options.thinkingDisplay ?? "summarized");
+        const result = supportsAdaptiveThinking(model.id, model.name)
             ? {
-                thinking: { type: "adaptive" },
-                output_config: { effort: mapThinkingLevelToEffort(options.reasoning, model.id) },
+                thinking: { type: "adaptive", ...(display !== undefined ? { display } : {}) },
+                output_config: { effort: mapThinkingLevelToEffort(model, options.reasoning) },
             }
             : (() => {
                 const defaultBudgets = {
@@ -606,20 +794,21 @@ function buildAdditionalModelRequestFields(model, options) {
                     low: 2048,
                     medium: 8192,
                     high: 16384,
-                    xhigh: 16384, // Older Claude models don't support xhigh, clamp to high budget
-                    max: 16384, // Older Claude models don't support max, clamp to high budget
+                    xhigh: 16384,
+                    max: 16384,
                 };
-                // Custom budgets override defaults (xhigh/max not in ThinkingBudgets, use high)
+                // Custom budgets override defaults (xhigh not in ThinkingBudgets, use high)
                 const level = options.reasoning === "xhigh" || options.reasoning === "max" ? "high" : options.reasoning;
                 const budget = options.thinkingBudgets?.[level] ?? defaultBudgets[options.reasoning];
                 return {
                     thinking: {
                         type: "enabled",
                         budget_tokens: budget,
+                        ...(display !== undefined ? { display } : {}),
                     },
                 };
             })();
-        if (!supportsAdaptiveThinking(model.id) && (options.interleavedThinking ?? true)) {
+        if (!supportsAdaptiveThinking(model.id, model.name) && (options.interleavedThinking ?? true)) {
             result.anthropic_beta = ["interleaved-thinking-2025-05-14"];
         }
         return result;