@node-llm/core 1.7.0 → 1.8.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"Moderation.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/Moderation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAoB,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAE,aAAa,EAA6C,MAAM,aAAa,CAAC;AAKvF,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,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;YAgCxD,cAAc;IAuC5B,OAAO,CAAC,qBAAqB;IAoC7B,OAAO,CAAC,aAAa;IAerB,OAAO,CAAC,YAAY;CA6BrB"}

package/dist/providers/bedrock/Moderation.js

@@ -0,0 +1,138 @@
+/**
+ * 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 { validateBedrockConfig, getBedrockEndpoint } from "./config.js";
+import { signRequest } from "../../utils/AwsSigV4.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { logger } from "../../utils/logger.js";
+export class BedrockModeration {
+    config;
+    authMode;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        this.authMode = validateBedrockConfig(config);
+        this.baseUrl = getBedrockEndpoint(config.region);
+    }
+    /**
+     * Execute a moderation request against Bedrock Guardrails.
+     */
+    async execute(request) {
+        const { guardrailIdentifier, guardrailVersion } = this.config;
+        if (!guardrailIdentifier || !guardrailVersion) {
+            throw new Error("Bedrock moderation requires 'bedrockGuardrailIdentifier' and 'bedrockGuardrailVersion' to be configured.");
+        }
+        const inputs = Array.isArray(request.input) ? request.input : [request.input];
+        const results = [];
+        // Process each input against the guardrail
+        // Note: Bedrock ApplyGuardrail accepts a list of content blocks,
+        // but usually we want to moderate individual strings to get back granular results.
+        for (const text of inputs) {
+            const result = await this.applyGuardrail(text, guardrailIdentifier, guardrailVersion, request.requestTimeout);
+            results.push(result);
+        }
+        return {
+            id: `bedrock-mod-${Date.now()}`,
+            model: `guardrail:${guardrailIdentifier}:${guardrailVersion}`,
+            results
+        };
+    }
+    async applyGuardrail(text, id, version, timeout) {
+        const encodedId = encodeURIComponent(id);
+        const encodedVersion = encodeURIComponent(version);
+        const url = `${this.baseUrl}/guardrail/${encodedId}/version/${encodedVersion}/apply`;
+        const body = JSON.stringify({
+            content: [{ text: { text } }],
+            source: "INPUT"
+        });
+        const headers = this.buildHeaders(url, body);
+        logger.logRequest("Bedrock Moderation", "POST", url, { text });
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers,
+            body
+        }, timeout ?? this.config.requestTimeout);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Bedrock Moderation API error (${response.status}): ${errorText}`);
+        }
+        const json = await response.json();
+        logger.logResponse("Bedrock Moderation", response.status, response.statusText, json);
+        return this.mapToModerationResult(json);
+    }
+    mapToModerationResult(response) {
+        const flagged = response.action === "BLOCK";
+        const categories = {};
+        const category_scores = {};
+        // Map Bedrock assessments to standard categories
+        if (response.assessments) {
+            for (const assessment of response.assessments) {
+                // Content Policy Filters (Hate, Violence, etc.)
+                if (assessment.contentPolicy?.filters) {
+                    for (const filter of assessment.contentPolicy.filters) {
+                        const key = filter.type.toLowerCase();
+                        const isBlocked = filter.action === "BLOCK";
+                        categories[key] = isBlocked;
+                        // Map confidence to a 0-1 score
+                        category_scores[key] = this.mapConfidence(filter.confidence);
+                    }
+                }
+                // Topic Policy
+                if (assessment.topicPolicy?.topics) {
+                    for (const topic of assessment.topicPolicy.topics) {
+                        categories[`topic_${topic.name.toLowerCase()}`] = topic.action === "BLOCK";
+                        category_scores[`topic_${topic.name.toLowerCase()}`] = 1.0;
+                    }
+                }
+            }
+        }
+        return {
+            flagged,
+            categories,
+            category_scores
+        };
+    }
+    mapConfidence(confidence) {
+        switch (confidence) {
+            case "HIGH":
+                return 0.9;
+            case "MEDIUM":
+                return 0.5;
+            case "LOW":
+                return 0.1;
+            case "NONE":
+                return 0.0;
+            default:
+                return 0.0;
+        }
+    }
+    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,
+                credentials,
+                region: this.config.region,
+                service: "bedrock"
+            });
+            Object.assign(headers, signedHeaders);
+        }
+        return headers;
+    }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Bedrock Streaming Handler
+ *
+ * Handles streaming responses from Bedrock ConverseStream API.
+ * Parses the AWS EventStream binary format to extract JSON chunks.
+ */
+import { ChatRequest, ChatChunk } from "../Provider.js";
+import { BedrockConfig } from "./config.js";
+export declare class BedrockStreaming {
+    private readonly config;
+    private readonly authMode;
+    private readonly baseUrl;
+    constructor(config: BedrockConfig);
+    execute(request: ChatRequest, controller?: AbortController): AsyncGenerator<ChatChunk>;
+    /**
+     * Parse a Bedrock ConverseStream event into a NodeLLM ChatChunk.
+     */
+    private parseEvent;
+    private buildHeaders;
+}
+//# sourceMappingURL=Streaming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Streaming.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/Streaming.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,SAAS,EAAS,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAA6C,MAAM,aAAa,CAAC;AAOvF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,aAAa;IAM1B,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,SAAS,CAAC;IA8H7F;;OAEG;IACH,OAAO,CAAC,UAAU;IAyGlB,OAAO,CAAC,YAAY;CAsCrB"}

package/dist/providers/bedrock/Streaming.js

@@ -0,0 +1,240 @@
+/**
+ * Bedrock Streaming Handler
+ *
+ * Handles streaming responses from Bedrock ConverseStream API.
+ * Parses the AWS EventStream binary format to extract JSON chunks.
+ */
+import { validateBedrockConfig, getBedrockEndpoint } from "./config.js";
+import { signRequest } from "../../utils/AwsSigV4.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { logger } from "../../utils/logger.js";
+import { buildConverseRequest } from "./mapper.js";
+import { ModelRegistry } from "../../models/ModelRegistry.js";
+export class BedrockStreaming {
+    config;
+    authMode;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        this.authMode = validateBedrockConfig(config);
+        this.baseUrl = getBedrockEndpoint(config.region);
+    }
+    async *execute(request, controller) {
+        const internalController = new AbortController();
+        const abortController = controller || internalController;
+        const signal = request.signal ? request.signal : abortController.signal;
+        const currentToolCalls = new Map();
+        let currentReasoning = "";
+        const modelId = request.model;
+        const url = `${this.baseUrl}/model/${modelId}/converse-stream`;
+        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);
+        const headers = this.buildHeaders(url, bodyJson, request.headers);
+        logger.logRequest("Bedrock", "POST", url, body);
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers,
+            body: bodyJson,
+            signal
+        }, request.requestTimeout ?? this.config.requestTimeout);
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.logResponse("Bedrock", response.status, response.statusText, errorText);
+            throw new Error(`Bedrock Streaming Error (${response.status}): ${errorText}`);
+        }
+        if (!response.body) {
+            throw new Error("No response body from Bedrock streaming");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = new Uint8Array(0);
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                // Append new data to buffer
+                const newBuffer = new Uint8Array(buffer.length + value.length);
+                newBuffer.set(buffer);
+                newBuffer.set(value, buffer.length);
+                buffer = newBuffer;
+                // Parse messages from buffer
+                while (buffer.length >= 12) {
+                    const totalLength = new DataView(buffer.buffer, buffer.byteOffset, 4).getUint32(0);
+                    if (totalLength < 16 || totalLength > 1024 * 1024) {
+                        // Safety check: skip if total length is unreasonable
+                        logger.error(`Bedrock stream: invalid total length ${totalLength}`);
+                        buffer = buffer.slice(4);
+                        continue;
+                    }
+                    if (buffer.length < totalLength) {
+                        break; // Wait for more data
+                    }
+                    const headersLength = new DataView(buffer.buffer, buffer.byteOffset + 4, 4).getUint32(0);
+                    if (headersLength + 16 > totalLength) {
+                        logger.error(`Bedrock stream: invalid headers length ${headersLength} for total length ${totalLength}`);
+                        buffer = buffer.slice(totalLength);
+                        continue;
+                    }
+                    const payloadLength = totalLength - headersLength - 16;
+                    const payloadOffset = 12 + headersLength;
+                    const payload = buffer.slice(payloadOffset, payloadOffset + payloadLength);
+                    const chunkJson = decoder.decode(payload);
+                    try {
+                        const event = JSON.parse(chunkJson);
+                        const chatChunk = this.parseEvent(event, currentToolCalls, (text) => {
+                            currentReasoning += text;
+                        }, modelId);
+                        if (chatChunk) {
+                            yield chatChunk;
+                        }
+                    }
+                    catch (e) {
+                        // Might be a binary event or malformed JSON (though Bedrock uses JSON in payload)
+                        logger.debug("Failed to parse Bedrock event payload", { chunkJson, error: e });
+                    }
+                    // Advance buffer
+                    buffer = buffer.slice(totalLength);
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Parse a Bedrock ConverseStream event into a NodeLLM ChatChunk.
+     */
+    parseEvent(event, toolCalls, onReasoning, modelId) {
+        // Bedrock ConverseStream events can be wrapped or unwrapped depending on model/service version
+        const contentBlockStart = event.contentBlockStart;
+        const contentBlockDelta = event.contentBlockDelta || (event.delta ? event : null);
+        const contentBlockStop = event.contentBlockStop;
+        const messageStop = event.messageStop || (event.stopReason ? event : null);
+        const metadata = event.metadata || (event.usage ? event : null);
+        // 1. Content Block Start (Initialize tools or reasoning)
+        if (contentBlockStart) {
+            const { contentBlockIndex, start } = contentBlockStart;
+            if (start?.toolUse) {
+                toolCalls.set(contentBlockIndex, {
+                    id: start.toolUse.toolUseId,
+                    name: start.toolUse.name,
+                    input: ""
+                });
+            }
+            if (start?.reasoningContent) {
+                return { content: "", thinking: { text: "" }, reasoning: "" };
+            }
+        }
+        // 2. Content Block Delta (Accumulate text, tools, or reasoning)
+        if (contentBlockDelta) {
+            const delta = contentBlockDelta.delta || contentBlockDelta;
+            const contentBlockIndex = contentBlockDelta.contentBlockIndex ?? 0;
+            if (delta.text) {
+                return { content: delta.text };
+            }
+            if (delta.reasoningContent?.text) {
+                onReasoning(delta.reasoningContent.text);
+                return {
+                    content: "",
+                    thinking: { text: delta.reasoningContent.text },
+                    reasoning: delta.reasoningContent.text
+                };
+            }
+            if (delta.toolUse) {
+                const toolCall = toolCalls.get(contentBlockIndex);
+                if (toolCall) {
+                    toolCall.input += delta.toolUse.input;
+                    return null;
+                }
+            }
+        }
+        // 3. Content Block Stop (Finalize tool calls)
+        if (contentBlockStop) {
+            const { contentBlockIndex } = contentBlockStop;
+            const toolCall = toolCalls.get(contentBlockIndex);
+            if (toolCall) {
+                toolCalls.delete(contentBlockIndex);
+                return {
+                    content: "",
+                    tool_calls: [
+                        {
+                            id: toolCall.id,
+                            type: "function",
+                            function: {
+                                name: toolCall.name,
+                                arguments: toolCall.input
+                            }
+                        }
+                    ]
+                };
+            }
+        }
+        // 4. Message Stop
+        if (event.messageStop) {
+            return {
+                content: "",
+                done: true,
+                finish_reason: event.messageStop.stopReason
+            };
+        }
+        // 5. Metadata (Usage)
+        if (event.metadata && event.metadata.usage) {
+            const rawUsage = {
+                input_tokens: event.metadata.usage.inputTokens,
+                output_tokens: event.metadata.usage.outputTokens,
+                total_tokens: event.metadata.usage.totalTokens,
+                cached_tokens: event.metadata.usage.cacheReadInputTokens,
+                cache_creation_tokens: event.metadata.usage.cacheWriteInputTokens
+            };
+            const usage = ModelRegistry.calculateCost(rawUsage, modelId, "bedrock");
+            const metadata = event.metadata.trace ? { trace: event.metadata.trace } : undefined;
+            return { content: "", usage, done: true, metadata };
+        }
+        return null;
+    }
+    buildHeaders(url, body, additionalHeaders) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...additionalHeaders
+        };
+        if (this.authMode === "apiKey") {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        else {
+            const signedHeaders = signRequest({
+                method: "POST",
+                url,
+                body,
+                credentials: {
+                    accessKeyId: this.config.accessKeyId,
+                    secretAccessKey: this.config.secretAccessKey,
+                    sessionToken: this.config.sessionToken
+                },
+                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/config.d.ts

@@ -0,0 +1,57 @@
+/**
+ * AWS Bedrock Provider Configuration
+ *
+ * Supports two authentication modes:
+ * 1. API Key (Bearer token) - Simplest, for long-term API keys
+ * 2. SigV4 (IAM credentials) - For EC2/ECS/Lambda with IAM roles
+ */
+export interface BedrockConfig {
+    /**
+     * AWS Region where Bedrock is enabled.
+     * Example: "us-east-1", "us-west-2"
+     */
+    region: string;
+    /**
+     * Long-term API key generated from AWS Bedrock console.
+     * When provided, uses simple Bearer token authentication.
+     * Mutually exclusive with accessKeyId/secretAccessKey.
+     */
+    apiKey?: string;
+    /**
+     * AWS Access Key ID.
+     * Required when using SigV4 authentication (no apiKey).
+     */
+    accessKeyId?: string;
+    /**
+     * AWS Secret Access Key.
+     * Required when using SigV4 authentication (no apiKey).
+     */
+    secretAccessKey?: string;
+    /**
+     * AWS Session Token (optional).
+     * Required for temporary credentials from STS, SSO, or assumed roles.
+     */
+    sessionToken?: string;
+    /**
+     * Request timeout in milliseconds.
+     * Default: 120000 (2 minutes)
+     */
+    requestTimeout?: number;
+    /**
+     * Default Bedrock Guardrail identifier (ID or ARN).
+     */
+    guardrailIdentifier?: string;
+    /**
+     * Default Bedrock Guardrail version (e.g., "1", "DRAFT").
+     */
+    guardrailVersion?: string;
+}
+/**
+ * Validates the configuration and determines the auth mode.
+ */
+export declare function validateBedrockConfig(config: BedrockConfig): "apiKey" | "sigv4";
+/**
+ * Build the Bedrock Runtime endpoint URL for a given region.
+ */
+export declare function getBedrockEndpoint(region: string): string;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAKf;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAKhB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAKtB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,QAAQ,GAAG,OAAO,CAuB/E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEzD"}

package/dist/providers/bedrock/config.js

@@ -0,0 +1,33 @@
+/**
+ * AWS Bedrock Provider Configuration
+ *
+ * Supports two authentication modes:
+ * 1. API Key (Bearer token) - Simplest, for long-term API keys
+ * 2. SigV4 (IAM credentials) - For EC2/ECS/Lambda with IAM roles
+ */
+/**
+ * Validates the configuration and determines the auth mode.
+ */
+export function validateBedrockConfig(config) {
+    if (!config.region) {
+        throw new Error("BedrockConfig: region is required");
+    }
+    const hasApiKey = !!config.apiKey;
+    const hasSigV4 = !!(config.accessKeyId && config.secretAccessKey);
+    if (hasApiKey && hasSigV4) {
+        throw new Error("BedrockConfig: provide either apiKey OR accessKeyId/secretAccessKey, not both");
+    }
+    if (hasApiKey) {
+        return "apiKey";
+    }
+    if (hasSigV4) {
+        return "sigv4";
+    }
+    throw new Error("BedrockConfig: provide either apiKey OR accessKeyId/secretAccessKey");
+}
+/**
+ * Build the Bedrock Runtime endpoint URL for a given region.
+ */
+export function getBedrockEndpoint(region) {
+    return `https://bedrock-runtime.${region}.amazonaws.com`;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Bedrock Provider - Public Exports
+ */
+export declare function registerBedrockProvider(): void;
+export { BedrockProvider, BedrockConfig } from "./BedrockProvider.js";
+export { BedrockChat } from "./Chat.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,wBAAgB,uBAAuB,SAuBtC;AAED,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,cAAc,YAAY,CAAC"}

package/dist/providers/bedrock/index.js

@@ -0,0 +1,30 @@
+/**
+ * Bedrock Provider - Public Exports
+ */
+import { config as globalConfig } from "../../config.js";
+import { providerRegistry } from "../registry.js";
+import { BedrockProvider } from "./BedrockProvider.js";
+export function registerBedrockProvider() {
+    providerRegistry.register("bedrock", (config) => {
+        const cfg = config || globalConfig;
+        const region = cfg.bedrockRegion;
+        if (!region) {
+            throw new Error("bedrockRegion is not set in config or AWS_REGION environment variable");
+        }
+        // Pass all available credentials to the provider.
+        // BedrockProvider.validateBedrockConfig will ensure they are mutually exclusive.
+        const bedrockConfig = {
+            region,
+            apiKey: cfg.bedrockApiKey,
+            accessKeyId: cfg.bedrockAccessKeyId,
+            secretAccessKey: cfg.bedrockSecretAccessKey,
+            sessionToken: cfg.bedrockSessionToken,
+            guardrailIdentifier: cfg.bedrockGuardrailIdentifier,
+            guardrailVersion: cfg.bedrockGuardrailVersion
+        };
+        return new BedrockProvider(bedrockConfig);
+    });
+}
+export { BedrockProvider } from "./BedrockProvider.js";
+export { BedrockChat } from "./Chat.js";
+export * from "./types.js";

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

@@ -0,0 +1,37 @@
+/**
+ * Bedrock Message Mapper
+ *
+ * Converts NodeLLM messages to Bedrock Converse API format.
+ * Handles system messages, tool calls, and content blocks.
+ */
+import { Message } from "../../chat/Message.js";
+import { ToolDefinition } from "../../chat/Tool.js";
+import { BedrockMessage, BedrockContentBlock, BedrockConverseRequest, BedrockToolConfig } from "./types.js";
+import { ThinkingConfig } from "../../providers/Provider.js";
+/**
+ * Convert NodeLLM messages to Bedrock Converse format.
+ * Extracts system messages to the top-level system field.
+ */
+export declare function convertMessages(messages: Message[]): {
+    messages: BedrockMessage[];
+    system?: BedrockContentBlock[];
+};
+/**
+ * Convert NodeLLM tool definitions to Bedrock tool config.
+ */
+export declare function convertTools(tools?: ToolDefinition[]): BedrockToolConfig | undefined;
+/**
+ * Build a complete Bedrock Converse request from NodeLLM ChatRequest.
+ */
+export declare function buildConverseRequest(messages: Message[], tools?: ToolDefinition[], options?: {
+    maxTokens?: number;
+    temperature?: number;
+    thinking?: ThinkingConfig;
+    guardrail?: {
+        guardrailIdentifier: string;
+        guardrailVersion: string;
+        trace?: "enabled" | "disabled";
+    };
+    additionalModelRequestFields?: Record<string, any>;
+}): BedrockConverseRequest;
+//# sourceMappingURL=mapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/mapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAiD7D;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG;IACpD,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,mBAAmB,EAAE,CAAC;CAChC,CAuFA;AAMD;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,cAAc,EAAE,GAAG,iBAAiB,GAAG,SAAS,CAgBpF;AAMD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,CAAC,EAAE,cAAc,EAAE,EACxB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,SAAS,CAAC,EAAE;QACV,mBAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAgB,EAAE,MAAM,CAAC;QACzB,KAAK,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;KAChC,CAAC;IACF,4BAA4B,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACpD,GACA,sBAAsB,CAmDxB"}