@signageos/lib 23.15.1 → 23.16.0

package/dist/AWS/Bedrock.d.ts

@@ -0,0 +1,48 @@
+import { BedrockRuntimeClientConfig, ConverseResponse, ConverseStreamResponse, GetAsyncInvokeCommandInput, GetAsyncInvokeResponse, ListAsyncInvokesCommandInput, ListAsyncInvokesResponse, StartAsyncInvokeCommandInput, StartAsyncInvokeResponse } from '@aws-sdk/client-bedrock-runtime';
+import { SendMessageInput } from './BedrockTypes';
+export interface IAwsBedrock {
+    /**
+     * Send a message to a Bedrock model
+     * More info: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand/
+     * @param input - The input for the message
+     * @returns The response from the message
+     */
+    sendMessage(input: SendMessageInput): Promise<ConverseResponse>;
+    /**
+     * Send a message to a Bedrock model with streaming response. Could be used for cases when you expect to receive a stream of data from the model.
+     * More info: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand/
+     * @param input - The input for the message
+     * @returns The response from the message
+     */
+    sendMessageWithStream(input: SendMessageInput): Promise<ConverseStreamResponse>;
+    /**
+     * Send an asynchronous request to a Bedrock model. Could be used for cases when you expect that the request will take a long time to complete.
+     * More info: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/StartAsyncInvokeCommand/
+     * @param input - The input for the request
+     * @returns The response from the request
+     */
+    sendAsyncRequest(input: StartAsyncInvokeCommandInput): Promise<StartAsyncInvokeResponse>;
+    /**
+     * Get the status of an asynchronous request to a Bedrock model.
+     * More info: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/GetAsyncInvokeCommand/
+     * @param input - The input for the request
+     * @returns The response from the request
+     */
+    getAsyncRequestStatus(input: GetAsyncInvokeCommandInput): Promise<GetAsyncInvokeResponse>;
+    /**
+     * List all asynchronous requests to a Bedrock model.
+     * More info: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ListAsyncRequestsCommand/
+     * @param input - The input for the request
+     * @returns The response from the request
+     */
+    listAsyncRequests(input: ListAsyncInvokesCommandInput): Promise<ListAsyncInvokesResponse>;
+}
+export declare class AwsBedrock implements IAwsBedrock {
+    private client;
+    constructor(config: BedrockRuntimeClientConfig);
+    sendMessage(input: SendMessageInput): Promise<ConverseResponse>;
+    sendMessageWithStream(input: SendMessageInput): Promise<ConverseStreamResponse>;
+    sendAsyncRequest(input: StartAsyncInvokeCommandInput): Promise<StartAsyncInvokeResponse>;
+    getAsyncRequestStatus(input: GetAsyncInvokeCommandInput): Promise<GetAsyncInvokeResponse>;
+    listAsyncRequests(input: ListAsyncInvokesCommandInput): Promise<ListAsyncInvokesResponse>;
+}

package/dist/AWS/Bedrock.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsBedrock = void 0;
+var client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
+var AwsBedrock = /** @class */ (function () {
+    function AwsBedrock(config) {
+        this.client = new client_bedrock_runtime_1.BedrockRuntimeClient(config);
+    }
+    AwsBedrock.prototype.sendMessage = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var command;
+            return __generator(this, function (_a) {
+                command = new client_bedrock_runtime_1.ConverseCommand(input);
+                return [2 /*return*/, this.client.send(command)];
+            });
+        });
+    };
+    AwsBedrock.prototype.sendMessageWithStream = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var command;
+            return __generator(this, function (_a) {
+                command = new client_bedrock_runtime_1.ConverseStreamCommand(input);
+                return [2 /*return*/, this.client.send(command)];
+            });
+        });
+    };
+    AwsBedrock.prototype.sendAsyncRequest = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var command;
+            return __generator(this, function (_a) {
+                command = new client_bedrock_runtime_1.StartAsyncInvokeCommand(input);
+                return [2 /*return*/, this.client.send(command)];
+            });
+        });
+    };
+    AwsBedrock.prototype.getAsyncRequestStatus = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var command;
+            return __generator(this, function (_a) {
+                command = new client_bedrock_runtime_1.GetAsyncInvokeCommand(input);
+                return [2 /*return*/, this.client.send(command)];
+            });
+        });
+    };
+    AwsBedrock.prototype.listAsyncRequests = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var command;
+            return __generator(this, function (_a) {
+                command = new client_bedrock_runtime_1.ListAsyncInvokesCommand(input);
+                return [2 /*return*/, this.client.send(command)];
+            });
+        });
+    };
+    return AwsBedrock;
+}());
+exports.AwsBedrock = AwsBedrock;
+//# sourceMappingURL=Bedrock.js.map

package/dist/AWS/Bedrock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bedrock.js","sourceRoot":"","sources":["../../src/AWS/Bedrock.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0EAgByC;AA6CzC;IAGC,oBAAY,MAAkC;QAC7C,IAAI,CAAC,MAAM,GAAG,IAAI,6CAAoB,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;IAEK,gCAAW,GAAjB,UAAkB,KAAuB;;;;gBAElC,OAAO,GAAG,IAAI,wCAAe,CAAC,KAAK,CAAC,CAAC;gBAC3C,sBAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAC;;;KACjC;IAEK,0CAAqB,GAA3B,UAA4B,KAAuB;;;;gBAE5C,OAAO,GAAG,IAAI,8CAAqB,CAAC,KAAK,CAAC,CAAC;gBACjD,sBAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAC;;;KACjC;IAEK,qCAAgB,GAAtB,UAAuB,KAAmC;;;;gBACnD,OAAO,GAAG,IAAI,gDAAuB,CAAC,KAAK,CAAC,CAAC;gBACnD,sBAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAC;;;KACjC;IAEK,0CAAqB,GAA3B,UAA4B,KAAiC;;;;gBACtD,OAAO,GAAG,IAAI,8CAAqB,CAAC,KAAK,CAAC,CAAC;gBACjD,sBAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAC;;;KACjC;IAEK,sCAAiB,GAAvB,UAAwB,KAAmC;;;;gBACpD,OAAO,GAAG,IAAI,gDAAuB,CAAC,KAAK,CAAC,CAAC;gBACnD,sBAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAC;;;KACjC;IACF,iBAAC;AAAD,CAAC,AAjCD,IAiCC;AAjCY,gCAAU"}

package/dist/AWS/BedrockTypes.d.ts

@@ -0,0 +1,21 @@
+import { GuardrailConfiguration, Message, SystemContentBlock } from '@aws-sdk/client-bedrock-runtime/dist-types/models/models_0';
+export interface SendMessageInput {
+    /**
+     * The model to use for the message.
+     * More info: https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html#model-ids-arns
+     */
+    modelId: string;
+    /**
+     * The messages to send to the model. Could be text, images, audio, video, etc.
+     */
+    messages: Message[];
+    /**
+     * A prompt that provides instructions or context to the model about the task it should perform, or the persona it should adopt during the conversation.
+     */
+    system?: SystemContentBlock[];
+    /**
+     * The guardrails to apply to the conversation. Guardrails are used to enforce certain rules or constraints on the model's behavior. For example, you can use guardrails to prevent the model from generating certain content or from using certain tools.
+     * More info: https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html
+     */
+    guardrailConfig?: GuardrailConfiguration | undefined;
+}

package/dist/AWS/BedrockTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BedrockTypes.js.map

package/dist/AWS/BedrockTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BedrockTypes.js","sourceRoot":"","sources":["../../src/AWS/BedrockTypes.ts"],"names":[],"mappings":""}

package/dist/AWS/MockBedrock.d.ts

@@ -0,0 +1,10 @@
+import { ConverseStreamResponse, StartAsyncInvokeCommandInput, StartAsyncInvokeResponse, GetAsyncInvokeCommandInput, GetAsyncInvokeResponse, ListAsyncInvokesCommandInput, ListAsyncInvokesResponse, ConverseResponse } from '@aws-sdk/client-bedrock-runtime';
+import { IAwsBedrock } from './Bedrock';
+import { SendMessageInput } from './BedrockTypes';
+export declare class MockBedrock implements IAwsBedrock {
+    sendMessageWithStream(_input: SendMessageInput): Promise<ConverseStreamResponse>;
+    sendAsyncRequest(_input: StartAsyncInvokeCommandInput): Promise<StartAsyncInvokeResponse>;
+    getAsyncRequestStatus(_input: GetAsyncInvokeCommandInput): Promise<GetAsyncInvokeResponse>;
+    listAsyncRequests(_input: ListAsyncInvokesCommandInput): Promise<ListAsyncInvokesResponse>;
+    sendMessage(_input: SendMessageInput): Promise<ConverseResponse>;
+}

package/dist/AWS/MockBedrock.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBedrock = void 0;
+var client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
+var MockBedrock = /** @class */ (function () {
+    function MockBedrock() {
+    }
+    MockBedrock.prototype.sendMessageWithStream = function (_input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var asyncIterator, result;
+            return __generator(this, function (_a) {
+                asyncIterator = (function () {
+                    return __asyncGenerator(this, arguments, function () {
+                        var output;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    output = {
+                                        messageStart: {
+                                            role: client_bedrock_runtime_1.ConversationRole.USER,
+                                        },
+                                    };
+                                    return [4 /*yield*/, __await(output)];
+                                case 1: return [4 /*yield*/, _a.sent()];
+                                case 2:
+                                    _a.sent();
+                                    return [4 /*yield*/, __await({
+                                            messageStop: {
+                                                stopReason: client_bedrock_runtime_1.StopReason.CONTENT_FILTERED,
+                                            },
+                                        })];
+                                case 3: return [4 /*yield*/, _a.sent()];
+                                case 4:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    });
+                })();
+                result = {
+                    stream: asyncIterator,
+                };
+                return [2 /*return*/, result];
+            });
+        });
+    };
+    MockBedrock.prototype.sendAsyncRequest = function (_input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        invocationArn: 'arn:aws:bedrock:eu-central-1:123:async-invoke/abc',
+                    }];
+            });
+        });
+    };
+    MockBedrock.prototype.getAsyncRequestStatus = function (_input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        invocationArn: 'arn:aws:bedrock:eu-central-1:123:async-invoke/abc',
+                        status: 'Completed',
+                        modelArn: 'arn:aws:bedrock:eu-central-1:123:model/abc',
+                        submitTime: new Date(),
+                        outputDataConfig: undefined,
+                    }];
+            });
+        });
+    };
+    MockBedrock.prototype.listAsyncRequests = function (_input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        nextToken: undefined,
+                        asyncInvokeSummaries: [],
+                    }];
+            });
+        });
+    };
+    MockBedrock.prototype.sendMessage = function (_input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        output: {
+                            message: {
+                                content: [{ text: 'Hello, world!' }],
+                                role: client_bedrock_runtime_1.ConversationRole.ASSISTANT,
+                            },
+                        },
+                        stopReason: client_bedrock_runtime_1.StopReason.CONTENT_FILTERED,
+                        usage: { inputTokens: 100, outputTokens: 100, totalTokens: 200 },
+                        metrics: {
+                            latencyMs: 100,
+                        },
+                    }];
+            });
+        });
+    };
+    return MockBedrock;
+}());
+exports.MockBedrock = MockBedrock;
+//# sourceMappingURL=MockBedrock.js.map

package/dist/AWS/MockBedrock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockBedrock.js","sourceRoot":"","sources":["../../src/AWS/MockBedrock.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0EAYyC;AAIzC;IAAA;IAwDA,CAAC;IAvDM,2CAAqB,GAA3B,UAA4B,MAAwB;;;;gBAC7C,aAAa,GAAG,CAAC;;;;;;oCAChB,MAAM,GAAyB;wCACpC,YAAY,EAAE;4CACb,IAAI,EAAE,yCAAgB,CAAC,IAAI;yCAC3B;qCACD,CAAC;iEACI,MAAM;wCAAZ,gCAAY;;oCAAZ,SAAY,CAAC;iEACP;4CACL,WAAW,EAAE;gDACZ,UAAU,EAAE,mCAAU,CAAC,gBAAgB;6CACvC;yCACD;wCAJD,gCAIC;;oCAJD,SAIC,CAAC;;;;;iBACF,CAAC,EAAE,CAAC;gBAEC,MAAM,GAA2B;oBACtC,MAAM,EAAE,aAAa;iBACrB,CAAC;gBACF,sBAAO,MAAM,EAAC;;;KACd;IACK,sCAAgB,GAAtB,UAAuB,MAAoC;;;gBAC1D,sBAAO;wBACN,aAAa,EAAE,mDAAmD;qBAClE,EAAC;;;KACF;IACK,2CAAqB,GAA3B,UAA4B,MAAkC;;;gBAC7D,sBAAO;wBACN,aAAa,EAAE,mDAAmD;wBAClE,MAAM,EAAE,WAAW;wBACnB,QAAQ,EAAE,4CAA4C;wBACtD,UAAU,EAAE,IAAI,IAAI,EAAE;wBACtB,gBAAgB,EAAE,SAAS;qBAC3B,EAAC;;;KACF;IACK,uCAAiB,GAAvB,UAAwB,MAAoC;;;gBAC3D,sBAAO;wBACN,SAAS,EAAE,SAAS;wBACpB,oBAAoB,EAAE,EAAE;qBACxB,EAAC;;;KACF;IACK,iCAAW,GAAjB,UAAkB,MAAwB;;;gBACzC,sBAAO;wBACN,MAAM,EAAE;4BACP,OAAO,EAAE;gCACR,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;gCACpC,IAAI,EAAE,yCAAgB,CAAC,SAAS;6BAChC;yBACD;wBACD,UAAU,EAAE,mCAAU,CAAC,gBAAgB;wBACvC,KAAK,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE;wBAChE,OAAO,EAAE;4BACR,SAAS,EAAE,GAAG;yBACd;qBACD,EAAC;;;KACF;IACF,kBAAC;AAAD,CAAC,AAxDD,IAwDC;AAxDY,kCAAW"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@signageos/lib",
-	"version": "23.15.1",
+	"version": "23.16.0",
 	"main": "./dist",
 	"type": "commonjs",
 	"files": [
@@ -39,7 +39,7 @@
 	"dependencies": {
 		"@signageos/amqp": "^0.2.1",
 		"@signageos/core": "^1.0.0",
-		"@signageos/lib-ci": "23.15.1",
+		"@signageos/lib-ci": "23.16.0",
 		"@signageos/metrics": "^1.0.0",
 		"@signageos/redis": "^2.2.0",
 		"async-lock": "1.4.0",
@@ -72,6 +72,7 @@
 		"zod": "^3.24.1"
 	},
 	"optionalPeerDependencies": {
+		"@aws-sdk/client-bedrock-runtime": "3.962.0",
 		"@aws-sdk/client-s3": "3.489.0",
 		"@aws-sdk/lib-storage": "3.489.0",
 		"@aws-sdk/s3-request-presigner": "3.489.0",
@@ -90,6 +91,7 @@
 		"npm": ">=10"
 	},
 	"devDependencies": {
+		"@aws-sdk/client-bedrock-runtime": "3.962.0",
 		"@aws-sdk/client-codeartifact": "3.645.0",
 		"@aws-sdk/client-s3": "3.489.0",
 		"@aws-sdk/lib-storage": "3.489.0",