@node-llm/core 1.7.0 → 1.8.0

package/dist/providers/bedrock/Chat.js

@@ -0,0 +1,170 @@
+/**
+ * Bedrock Chat Handler
+ *
+ * Executes chat requests against the Bedrock Converse API.
+ */
+import { validateBedrockConfig, getBedrockEndpoint } from "./config.js";
+import { buildConverseRequest } from "./mapper.js";
+import { signRequest } from "../../utils/AwsSigV4.js";
+import { ModelRegistry } from "../../models/ModelRegistry.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { logger } from "../../utils/logger.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Chat Handler
+// ─────────────────────────────────────────────────────────────────────────────
+export class BedrockChat {
+    config;
+    authMode;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        this.authMode = validateBedrockConfig(config);
+        this.baseUrl = getBedrockEndpoint(config.region);
+    }
+    /**
+     * Execute a chat request against Bedrock Converse API.
+     */
+    async execute(request) {
+        const modelId = request.model;
+        const url = `${this.baseUrl}/model/${modelId}/converse`;
+        // Build the Bedrock request body
+        const guardrail = this.config.guardrailIdentifier && this.config.guardrailVersion
+            ? {
+                guardrailIdentifier: this.config.guardrailIdentifier,
+                guardrailVersion: this.config.guardrailVersion
+            }
+            : undefined;
+        const body = buildConverseRequest(request.messages, request.tools, {
+            maxTokens: request.max_tokens,
+            temperature: request.temperature,
+            thinking: request.thinking,
+            guardrail,
+            additionalModelRequestFields: request.additionalModelRequestFields
+        });
+        const bodyJson = JSON.stringify(body);
+        // Build headers based on auth mode
+        const headers = this.buildHeaders(url, bodyJson, request.headers);
+        logger.logRequest("Bedrock", "POST", url, body);
+        // Make the request
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers,
+            body: bodyJson
+        }, request.requestTimeout ?? this.config.requestTimeout);
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.logResponse("Bedrock", response.status, response.statusText, errorText);
+            let message = errorText;
+            // Improve clarity for known AWS errors
+            if (errorText.includes("INVALID_PAYMENT_INSTRUMENT")) {
+                message =
+                    "Billing setup incomplete for AWS Marketplace models. Ensure a credit card is set as default payment method.";
+            }
+            else if (errorText.includes("AccessDeniedException") &&
+                errorText.includes("model access")) {
+                message =
+                    "Access denied for this model. Ensure you have requested and been granted access in the AWS Bedrock console (Model Access section).";
+            }
+            else if (errorText.includes("ThrottlingException")) {
+                message = "Bedrock API throttling. Too many requests. Please retry with backoff.";
+            }
+            else if (errorText.includes("ValidationException")) {
+                message = `Bedrock validation error: ${errorText}`;
+            }
+            throw new Error(`Bedrock API error (${response.status}): ${message}`);
+        }
+        const json = (await response.json());
+        logger.logResponse("Bedrock", response.status, response.statusText, json);
+        const result = this.parseResponse(json);
+        if (result.usage) {
+            result.usage = ModelRegistry.calculateCost(result.usage, modelId, "bedrock");
+        }
+        return result;
+    }
+    /**
+     * Build request headers based on auth mode.
+     */
+    buildHeaders(url, body, additionalHeaders) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...additionalHeaders
+        };
+        if (this.authMode === "apiKey") {
+            // Simple Bearer token auth
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        else {
+            // SigV4 signing
+            const credentials = {
+                accessKeyId: this.config.accessKeyId,
+                secretAccessKey: this.config.secretAccessKey,
+                sessionToken: this.config.sessionToken
+            };
+            const signedHeaders = signRequest({
+                method: "POST",
+                url,
+                body,
+                credentials,
+                region: this.config.region,
+                service: "bedrock"
+            });
+            // Merge signed headers
+            headers["host"] = signedHeaders.host;
+            headers["x-amz-date"] = signedHeaders["x-amz-date"];
+            headers["x-amz-content-sha256"] = signedHeaders["x-amz-content-sha256"];
+            headers["Authorization"] = signedHeaders.authorization;
+            if (signedHeaders["x-amz-security-token"]) {
+                headers["x-amz-security-token"] = signedHeaders["x-amz-security-token"];
+            }
+        }
+        return headers;
+    }
+    /**
+     * Parse Bedrock response to NodeLLM format.
+     */
+    parseResponse(response) {
+        const message = response.output.message;
+        let content = null;
+        let thinkingText = null;
+        const toolCalls = [];
+        // Process content blocks
+        for (const block of message.content) {
+            if (block.text) {
+                content = content ? content + block.text : block.text;
+            }
+            if (block.reasoningContent?.text) {
+                thinkingText = thinkingText
+                    ? thinkingText + block.reasoningContent.text
+                    : block.reasoningContent.text;
+            }
+            if (block.toolUse) {
+                toolCalls.push({
+                    id: block.toolUse.toolUseId,
+                    type: "function",
+                    function: {
+                        name: block.toolUse.name,
+                        arguments: JSON.stringify(block.toolUse.input)
+                    }
+                });
+            }
+        }
+        // Build usage info
+        const usage = {
+            input_tokens: response.usage.inputTokens,
+            output_tokens: response.usage.outputTokens,
+            total_tokens: response.usage.totalTokens,
+            cached_tokens: response.usage.cacheReadInputTokens,
+            cache_creation_tokens: response.usage.cacheWriteInputTokens
+        };
+        return {
+            content,
+            thinking: thinkingText ? { text: thinkingText } : undefined,
+            reasoning: thinkingText || undefined, // Keep deprecated field for compat
+            tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage,
+            finish_reason: response.stopReason,
+            metadata: response.trace ? { trace: response.trace } : undefined
+        };
+    }
+}

package/dist/providers/bedrock/Embeddings.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Bedrock Embeddings Handler
+ *
+ * Executes embedding requests against the Bedrock InvokeModel API.
+ */
+import { EmbeddingRequest, EmbeddingResponse } from "../Provider.js";
+import { BedrockConfig } from "./config.js";
+export declare class BedrockEmbeddings {
+    private readonly config;
+    private readonly authMode;
+    private readonly baseUrl;
+    constructor(config: BedrockConfig);
+    /**
+     * Execute an embedding request against Bedrock InvokeModel API.
+     */
+    execute(request: EmbeddingRequest): Promise<EmbeddingResponse>;
+    /**
+     * Build request headers based on auth mode.
+     */
+    private buildHeaders;
+}
+//# sourceMappingURL=Embeddings.d.ts.map

package/dist/providers/bedrock/Embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Embeddings.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/Embeddings.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,aAAa,EAA6C,MAAM,aAAa,CAAC;AAwBvF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,aAAa;IAMjC;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAqDpE;;OAEG;IACH,OAAO,CAAC,YAAY;CAoCrB"}

package/dist/providers/bedrock/Embeddings.js

@@ -0,0 +1,100 @@
+/**
+ * Bedrock Embeddings Handler
+ *
+ * Executes embedding requests against the Bedrock InvokeModel API.
+ */
+import { validateBedrockConfig, getBedrockEndpoint } from "./config.js";
+import { signRequest } from "../../utils/AwsSigV4.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { logger } from "../../utils/logger.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Embeddings Handler
+// ─────────────────────────────────────────────────────────────────────────────
+export class BedrockEmbeddings {
+    config;
+    authMode;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        this.authMode = validateBedrockConfig(config);
+        this.baseUrl = getBedrockEndpoint(config.region);
+    }
+    /**
+     * Execute an embedding request against Bedrock InvokeModel API.
+     */
+    async execute(request) {
+        const modelId = request.model ?? "amazon.titan-embed-text-v2:0";
+        const url = `${this.baseUrl}/model/${modelId}/invoke`;
+        // Handle single vs multiple inputs (Titan only supports one at a time via InvokeModel)
+        const inputs = Array.isArray(request.input) ? request.input : [request.input];
+        const results = [];
+        let totalTokens = 0;
+        // Bedrock InvokeModel API for Titan embeddings processes one text at a time.
+        // We iterate through inputs and collect embeddings.
+        for (const text of inputs) {
+            const body = {
+                inputText: text,
+                // Titan V2 supports 256, 512, 1024 dimensions. NodeLLM doesn't have a standardized field for this yet,
+                // so we use the model's default (typically 1024 for V2) unless passed in headers/custom.
+                normalize: true
+            };
+            const bodyJson = JSON.stringify(body);
+            const headers = this.buildHeaders(url, bodyJson);
+            logger.logRequest("BedrockEmbeddings", "POST", url, body);
+            const response = await fetchWithTimeout(url, {
+                method: "POST",
+                headers,
+                body: bodyJson
+            }, request.requestTimeout ?? this.config.requestTimeout);
+            if (!response.ok) {
+                const errorText = await response.text();
+                logger.logResponse("BedrockEmbeddings", response.status, response.statusText, errorText);
+                throw new Error(`Bedrock Embeddings error (${response.status}): ${errorText}`);
+            }
+            const json = (await response.json());
+            results.push(json.embedding);
+            totalTokens += json.inputTextTokenCount;
+        }
+        return {
+            vectors: results,
+            model: modelId,
+            input_tokens: totalTokens,
+            dimensions: results[0]?.length || 0
+        };
+    }
+    /**
+     * Build request headers based on auth mode.
+     */
+    buildHeaders(url, body) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json"
+        };
+        if (this.authMode === "apiKey") {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        else {
+            const credentials = {
+                accessKeyId: this.config.accessKeyId,
+                secretAccessKey: this.config.secretAccessKey,
+                sessionToken: this.config.sessionToken
+            };
+            const signedHeaders = signRequest({
+                method: "POST",
+                url,
+                body: body,
+                credentials,
+                region: this.config.region,
+                service: "bedrock"
+            });
+            headers["host"] = signedHeaders.host;
+            headers["x-amz-date"] = signedHeaders["x-amz-date"];
+            headers["x-amz-content-sha256"] = signedHeaders["x-amz-content-sha256"];
+            headers["Authorization"] = signedHeaders.authorization;
+            if (signedHeaders["x-amz-security-token"]) {
+                headers["x-amz-security-token"] = signedHeaders["x-amz-security-token"];
+            }
+        }
+        return headers;
+    }
+}

package/dist/providers/bedrock/Image.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bedrock Image Generation Handler
+ *
+ * Supports Amazon Titan Image Generator and Stability.ai Stable Diffusion models.
+ */
+import { ImageRequest, ImageResponse } from "../Provider.js";
+import { BedrockConfig } from "./config.js";
+export declare class BedrockImage {
+    private readonly config;
+    private readonly baseUrl;
+    constructor(config: BedrockConfig);
+    /**
+     * Execute an image generation request.
+     */
+    execute(request: ImageRequest): Promise<ImageResponse>;
+    /**
+     * Build model-specific request body.
+     */
+    private buildRequestBody;
+    /**
+     * Parse model-specific response.
+     */
+    private parseResponse;
+    /**
+     * Parse size string (e.g. "1024x1024") into height and width.
+     */
+    private parseSize;
+    /**
+     * Build headers with SigV4 signing.
+     */
+    private buildHeaders;
+}
+//# sourceMappingURL=Image.d.ts.map

package/dist/providers/bedrock/Image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/Image.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAsB,MAAM,aAAa,CAAC;AAKhE,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,aAAa;IAKjC;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IA8B5D;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuCxB;;OAEG;IACH,OAAO,CAAC,aAAa;IAwBrB;;OAEG;IACH,OAAO,CAAC,SAAS;IAejB;;OAEG;IACH,OAAO,CAAC,YAAY;CAsCrB"}

package/dist/providers/bedrock/Image.js

@@ -0,0 +1,154 @@
+/**
+ * Bedrock Image Generation Handler
+ *
+ * Supports Amazon Titan Image Generator and Stability.ai Stable Diffusion models.
+ */
+import { getBedrockEndpoint } from "./config.js";
+import { signRequest } from "../../utils/AwsSigV4.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { logger } from "../../utils/logger.js";
+export class BedrockImage {
+    config;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        this.baseUrl = getBedrockEndpoint(config.region);
+    }
+    /**
+     * Execute an image generation request.
+     */
+    async execute(request) {
+        const modelId = request.model ?? "amazon.titan-image-generator-v2:0";
+        const url = `${this.baseUrl}/model/${modelId}/invoke`;
+        const body = this.buildRequestBody(modelId, request);
+        const bodyJson = JSON.stringify(body);
+        const headers = this.buildHeaders(url, bodyJson, request.headers);
+        logger.logRequest("BedrockImage", "POST", url, body);
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers,
+            body: bodyJson
+        }, request.requestTimeout ?? this.config.requestTimeout ?? 120000);
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.logResponse("BedrockImage", response.status, response.statusText, errorText);
+            throw new Error(`Bedrock Image Generation error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        return this.parseResponse(modelId, data);
+    }
+    /**
+     * Build model-specific request body.
+     */
+    buildRequestBody(modelId, request) {
+        const prompt = request.prompt;
+        // Amazon Titan
+        if (modelId.includes("amazon.titan-image")) {
+            return {
+                taskType: "TEXT_IMAGE",
+                textToImageParams: {
+                    text: prompt
+                },
+                imageGenerationConfig: {
+                    numberOfImages: request.n ?? 1,
+                    height: this.parseSize(request.size)?.height ?? 1024,
+                    width: this.parseSize(request.size)?.width ?? 1024,
+                    cfgScale: 8.0
+                }
+            };
+        }
+        // Stability AI (Stable Diffusion)
+        if (modelId.includes("stability.stable-diffusion")) {
+            return {
+                text_prompts: [
+                    {
+                        text: prompt,
+                        weight: 1
+                    }
+                ],
+                cfg_scale: 7,
+                steps: 30,
+                samples: request.n ?? 1,
+                width: this.parseSize(request.size)?.width ?? 1024,
+                height: this.parseSize(request.size)?.height ?? 1024
+            };
+        }
+        throw new Error(`Unsupported image generation model: ${modelId}`);
+    }
+    /**
+     * Parse model-specific response.
+     */
+    parseResponse(modelId, data) {
+        // Amazon Titan returns { images: ["base64", ...] }
+        if (modelId.includes("amazon.titan-image")) {
+            const base64 = data.images?.[0];
+            if (!base64)
+                throw new Error("No image data returned from Titan");
+            return {
+                data: base64,
+                mime_type: "image/png"
+            };
+        }
+        // Stability AI returns { artifacts: [ { base64: "...", ... } ] }
+        if (modelId.includes("stability.stable-diffusion")) {
+            const base64 = data.artifacts?.[0]?.base64;
+            if (!base64)
+                throw new Error("No image data returned from Stable Diffusion");
+            return {
+                data: base64,
+                mime_type: "image/png"
+            };
+        }
+        throw new Error(`Unsupported model response format: ${modelId}`);
+    }
+    /**
+     * Parse size string (e.g. "1024x1024") into height and width.
+     */
+    parseSize(size) {
+        if (!size)
+            return null;
+        const parts = size.toLowerCase().split("x");
+        const width = parts[0];
+        const height = parts[1];
+        if (width && height) {
+            return {
+                width: parseInt(width, 10),
+                height: parseInt(height, 10)
+            };
+        }
+        return null;
+    }
+    /**
+     * Build headers with SigV4 signing.
+     */
+    buildHeaders(url, body, additionalHeaders) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...additionalHeaders
+        };
+        if (this.config.apiKey) {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        else if (this.config.accessKeyId && this.config.secretAccessKey && this.config.region) {
+            const accessKeyId = this.config.accessKeyId;
+            const secretAccessKey = this.config.secretAccessKey;
+            const region = this.config.region;
+            const credentials = {
+                accessKeyId,
+                secretAccessKey,
+                sessionToken: this.config.sessionToken
+            };
+            const signedHeaders = signRequest({
+                method: "POST",
+                url,
+                body,
+                credentials,
+                region,
+                service: "bedrock"
+            });
+            return { ...headers, ...signedHeaders };
+        }
+        return headers;
+    }
+}

package/dist/providers/bedrock/Models.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bedrock Models Handler
+ *
+ * Lists and normalizes models from the Bedrock management API.
+ */
+import { BedrockConfig } from "./config.js";
+import { ModelInfo } from "../Provider.js";
+export declare class BedrockModels {
+    private readonly config;
+    private readonly baseUrl;
+    constructor(config: BedrockConfig);
+    /**
+     * List and normalize foundation models.
+     */
+    execute(): Promise<ModelInfo[]>;
+    /**
+     * Parse Bedrock model list into NodeLLM format.
+     */
+    private parseResponse;
+    /**
+     * Determine if a model should be included in the NodeLLM models list.
+     */
+    private shouldIncludeModel;
+    /**
+     * Map summary to Model info.
+     */
+    private mapToModel;
+    /**
+     * Normalize model ID for inference profiles if supported.
+     * Handles regional prefixes for Cross-Region Inference.
+     */
+    private normalizeModelId;
+}
+//# sourceMappingURL=Models.d.ts.map

package/dist/providers/bedrock/Models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Models.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/Models.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAyB,MAAM,aAAa,CAAC;AAGnE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAK3C,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,aAAa;IAOjC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAyCrC;;OAEG;IACH,OAAO,CAAC,aAAa;IAQrB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,OAAO,CAAC,UAAU;IA+BlB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;CAkBzB"}

package/dist/providers/bedrock/Models.js

@@ -0,0 +1,131 @@
+/**
+ * Bedrock Models Handler
+ *
+ * Lists and normalizes models from the Bedrock management API.
+ */
+import { validateBedrockConfig } from "./config.js";
+import { Capabilities } from "./Capabilities.js";
+import { signRequest } from "../../utils/AwsSigV4.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { logger } from "../../utils/logger.js";
+export class BedrockModels {
+    config;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        validateBedrockConfig(config);
+        // Management API uses a different subdomain than the runtime API
+        this.baseUrl = `https://bedrock.${config.region}.amazonaws.com`;
+    }
+    /**
+     * List and normalize foundation models.
+     */
+    async execute() {
+        const url = `${this.baseUrl}/foundation-models`;
+        const body = ""; // GET request
+        const credentials = {
+            accessKeyId: this.config.accessKeyId,
+            secretAccessKey: this.config.secretAccessKey,
+            sessionToken: this.config.sessionToken
+        };
+        const signedHeaders = signRequest({
+            method: "GET",
+            url,
+            body,
+            credentials,
+            region: this.config.region,
+            service: "bedrock"
+        });
+        logger.logRequest("Bedrock", "GET", url);
+        const response = await fetchWithTimeout(url, {
+            method: "GET",
+            headers: {
+                ...signedHeaders,
+                Accept: "application/json"
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.logResponse("Bedrock", response.status, response.statusText, errorText);
+            throw new Error(`Bedrock Models API error (${response.status}): ${errorText}`);
+        }
+        const json = (await response.json());
+        logger.logResponse("Bedrock", response.status, response.statusText, json);
+        return this.parseResponse(json);
+    }
+    /**
+     * Parse Bedrock model list into NodeLLM format.
+     */
+    parseResponse(response) {
+        const summaries = response.modelSummaries || [];
+        // Filter and map models
+        // We primarily focus on models that support text conversation (Converse API)
+        return summaries.filter((m) => this.shouldIncludeModel(m)).map((m) => this.mapToModel(m));
+    }
+    /**
+     * Determine if a model should be included in the NodeLLM models list.
+     */
+    shouldIncludeModel(summary) {
+        const modelId = summary.modelId;
+        // We only support Claude, DeepSeek, Mistral, Llama, and Titan for now.
+        // Exclude embedding models and image models unless we strictly want to list them.
+        const isSupportedFamily = modelId.includes("anthropic.claude") ||
+            modelId.includes("deepseek") ||
+            modelId.includes("mistral") ||
+            modelId.includes("meta.llama") ||
+            modelId.includes("amazon.nova") ||
+            modelId.includes("amazon.titan-text") ||
+            modelId.includes("amazon.titan-embed");
+        return isSupportedFamily;
+    }
+    /**
+     * Map summary to Model info.
+     */
+    mapToModel(summary) {
+        const modelId = summary.modelId;
+        const normalizedId = this.normalizeModelId(summary);
+        const capabilities = Capabilities.getCapabilities(modelId);
+        const pricing = Capabilities.getPricing(modelId);
+        const contextWindow = Capabilities.getContextWindow(modelId);
+        const maxTokens = Capabilities.getMaxOutputTokens(modelId);
+        return {
+            id: normalizedId,
+            name: summary.modelName || Capabilities.formatDisplayName(modelId),
+            provider: "bedrock",
+            family: Capabilities.getModelFamily(modelId),
+            context_window: contextWindow,
+            max_output_tokens: maxTokens,
+            modalities: {
+                input: summary.inputModalities || ["text"],
+                output: summary.outputModalities || ["text"]
+            },
+            capabilities,
+            pricing,
+            metadata: {
+                bedrock_model_id: modelId,
+                provider_name: summary.providerName,
+                inference_types: summary.inferenceTypesSupported || [],
+                streaming_supported: summary.responseStreamingSupported || false
+            }
+        };
+    }
+    /**
+     * Normalize model ID for inference profiles if supported.
+     * Handles regional prefixes for Cross-Region Inference.
+     */
+    normalizeModelId(summary) {
+        const modelId = summary.modelId;
+        const types = summary.inferenceTypesSupported || [];
+        // If it supports INFERENCE_PROFILE but NOT ON_DEMAND directly,
+        // it likely requires the regional prefix.
+        const needsPrefix = types.includes("INFERENCE_PROFILE") && !types.includes("ON_DEMAND");
+        if (needsPrefix) {
+            const region = this.config.region;
+            const prefix = region.split("-")[0]; // 'us', 'eu', 'ap'
+            if (prefix && !/^[a-z]{2}\./.test(modelId)) {
+                return `${prefix}.${modelId}`;
+            }
+        }
+        return modelId;
+    }
+}

package/dist/providers/bedrock/Moderation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Bedrock Moderation Handler
+ *
+ * Implements the standalone moderation endpoint using Bedrock Guardrails.
+ * Use this to check content for safety before sending it to an LLM.
+ */
+import { ModerationRequest, ModerationResponse } from "../Provider.js";
+import { BedrockConfig } from "./config.js";
+export declare class BedrockModeration {
+    private readonly config;
+    private readonly authMode;
+    private readonly baseUrl;
+    constructor(config: BedrockConfig);
+    /**
+     * Execute a moderation request against Bedrock Guardrails.
+     */
+    execute(request: ModerationRequest): Promise<ModerationResponse>;
+    private applyGuardrail;
+    private mapToModerationResult;
+    private mapConfidence;
+    private buildHeaders;
+}
+//# sourceMappingURL=Moderation.d.ts.map