@node-llm/core 1.6.2 → 1.8.0

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

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"}