@signageos/lib 23.23.1-master.4632 → 23.24.0-master.4637

package/dist/GCP/MockVertex.d.ts

@@ -0,0 +1,7 @@
+import { GenerateContentResponse } from '@google/genai';
+import { IGcpVertex } from './Vertex';
+import { GenerateContentInput } from './VertexTypes';
+export declare class MockVertex implements IGcpVertex {
+    generateContent(_input: GenerateContentInput): Promise<GenerateContentResponse>;
+    generateContentStream(input: GenerateContentInput): Promise<AsyncGenerator<GenerateContentResponse>>;
+}

package/dist/GCP/MockVertex.js

@@ -0,0 +1,102 @@
+"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.MockVertex = void 0;
+var genai_1 = require("@google/genai");
+var MockVertex = /** @class */ (function () {
+    function MockVertex() {
+    }
+    MockVertex.prototype.generateContent = function (_input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                /// GenerateContentResponse is a class with convenience getters (e.g. `.text`), so a real
+                /// instance is built and the canned fields are copied onto it.
+                return [2 /*return*/, Object.assign(new genai_1.GenerateContentResponse(), {
+                        candidates: [
+                            {
+                                content: { role: 'model', parts: [{ text: 'Hello, world!' }] },
+                                finishReason: genai_1.FinishReason.STOP,
+                            },
+                        ],
+                        usageMetadata: { promptTokenCount: 100, candidatesTokenCount: 100, totalTokenCount: 200 },
+                    })];
+            });
+        });
+    };
+    MockVertex.prototype.generateContentStream = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.generateContent(input)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, (function () {
+                                return __asyncGenerator(this, arguments, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, __await(response)];
+                                            case 1: return [4 /*yield*/, _a.sent()];
+                                            case 2:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                });
+                            })()];
+                }
+            });
+        });
+    };
+    return MockVertex;
+}());
+exports.MockVertex = MockVertex;
+//# sourceMappingURL=MockVertex.js.map

package/dist/GCP/MockVertex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockVertex.js","sourceRoot":"","sources":["../../src/GCP/MockVertex.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAsE;AAItE;IAAA;IAqBA,CAAC;IApBM,oCAAe,GAArB,UAAsB,MAA4B;;;gBACjD,yFAAyF;gBACzF,+DAA+D;gBAC/D,sBAAO,MAAM,CAAC,MAAM,CAAC,IAAI,+BAAuB,EAAE,EAAE;wBACnD,UAAU,EAAE;4BACX;gCACC,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,EAAE;gCAC9D,YAAY,EAAE,oBAAY,CAAC,IAAI;6BAC/B;yBACD;wBACD,aAAa,EAAE,EAAE,gBAAgB,EAAE,GAAG,EAAE,oBAAoB,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE;qBACzF,CAAC,EAAC;;;KACH;IAEK,0CAAqB,GAA3B,UAA4B,KAA2B;;;;;4BACrC,qBAAM,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAA;;wBAA5C,QAAQ,GAAG,SAAiC;wBAClD,sBAAO,CAAC;;;;iFACD,QAAQ;oDAAd,gCAAc;;gDAAd,SAAc,CAAC;;;;;6BACf,CAAC,EAAE,EAAC;;;;KACL;IACF,iBAAC;AAAD,CAAC,AArBD,IAqBC;AArBY,gCAAU"}

package/dist/GCP/Vertex.d.ts

@@ -0,0 +1,35 @@
+import { GenerateContentResponse, GoogleGenAIOptions } from '@google/genai';
+import { GenerateContentInput } from './VertexTypes';
+export interface IGcpVertex {
+    /**
+     * Generate content from a Gemini model on Vertex AI.
+     * More info: https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/inference
+     * @param input - The input for the generation request
+     * @returns The response from the model
+     */
+    generateContent(input: GenerateContentInput): Promise<GenerateContentResponse>;
+    /**
+     * Generate content from a Gemini model on Vertex AI with a streaming response.
+     * Could be used for cases when you expect to receive a stream of data from the model.
+     * More info: https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/inference#streaming
+     * @param input - The input for the generation request
+     * @returns An async generator yielding response chunks from the model
+     */
+    generateContentStream(input: GenerateContentInput): Promise<AsyncGenerator<GenerateContentResponse>>;
+}
+/**
+ * Minimal surface of the underlying GoogleGenAI client used by the wrapper.
+ * Kept narrow and public so tests can substitute a typed stub without any casts.
+ */
+export interface IGoogleGenAiClient {
+    models: {
+        generateContent(params: GenerateContentInput): Promise<GenerateContentResponse>;
+        generateContentStream(params: GenerateContentInput): Promise<AsyncGenerator<GenerateContentResponse>>;
+    };
+}
+export declare class GcpVertex implements IGcpVertex {
+    client: IGoogleGenAiClient;
+    constructor(options: Omit<GoogleGenAIOptions, 'vertexai'>);
+    generateContent(input: GenerateContentInput): Promise<GenerateContentResponse>;
+    generateContentStream(input: GenerateContentInput): Promise<AsyncGenerator<GenerateContentResponse>>;
+}

package/dist/GCP/Vertex.js

@@ -0,0 +1,75 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.GcpVertex = void 0;
+var genai_1 = require("@google/genai");
+var GcpVertex = /** @class */ (function () {
+    function GcpVertex(options) {
+        /// The wrapper is explicitly the Vertex AI entry point — the Gemini API-key mode is out of scope.
+        /// GCP authentication uses Application Default Credentials (https://cloud.google.com/docs/authentication/application-default-credentials).
+        this.client = new genai_1.GoogleGenAI(__assign(__assign({}, options), { vertexai: true }));
+    }
+    GcpVertex.prototype.generateContent = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.models.generateContent(input)];
+            });
+        });
+    };
+    GcpVertex.prototype.generateContentStream = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.models.generateContentStream(input)];
+            });
+        });
+    };
+    return GcpVertex;
+}());
+exports.GcpVertex = GcpVertex;
+//# sourceMappingURL=Vertex.js.map

package/dist/GCP/Vertex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vertex.js","sourceRoot":"","sources":["../../src/GCP/Vertex.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAyF;AAiCzF;IAGC,mBAAY,OAA6C;QACxD,kGAAkG;QAClG,2IAA2I;QAC3I,IAAI,CAAC,MAAM,GAAG,IAAI,mBAAW,uBAAM,OAAO,KAAE,QAAQ,EAAE,IAAI,IAAG,CAAC;IAC/D,CAAC;IAEK,mCAAe,GAArB,UAAsB,KAA2B;;;gBAChD,sBAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,EAAC;;;KACjD;IAEK,yCAAqB,GAA3B,UAA4B,KAA2B;;;gBACtD,sBAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAC;;;KACvD;IACF,gBAAC;AAAD,CAAC,AAhBD,IAgBC;AAhBY,8BAAS"}

package/dist/GCP/VertexTypes.d.ts

@@ -0,0 +1,16 @@
+import type { Content, GenerateContentConfig } from '@google/genai';
+/**
+ * Input for a Vertex AI Gemini content generation request.
+ *
+ * Mirrors the SDK's `GenerateContentParameters` with `contents` narrowed to the explicit
+ * `Content[]` form (the SDK also accepts string/part shorthands, which are avoided in the
+ * shared surface so requests stay unambiguous).
+ */
+export interface GenerateContentInput {
+    /** Gemini model id to use, e.g. `gemini-2.5-flash` */
+    model: string;
+    /** Conversation contents (user/model turns with text and image parts) */
+    contents: Content[];
+    /** Optional model parameters (system instruction, response mime type, thinking config, token caps, ...) */
+    config?: GenerateContentConfig;
+}

package/dist/GCP/VertexTypes.js

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

package/dist/GCP/VertexTypes.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@signageos/lib",
-	"version": "23.23.1-master.4632",
+	"version": "23.24.0-master.4637",
 	"main": "./dist",
 	"type": "commonjs",
 	"files": [
@@ -40,7 +40,7 @@
 	"dependencies": {
 		"@signageos/amqp": "^0.14.0",
 		"@signageos/core": "^1.5.0",
-		"@signageos/lib-ci": "23.23.1-master.4632",
+		"@signageos/lib-ci": "23.24.0-master.4637",
 		"@signageos/metrics": "^1.0.0",
 		"@signageos/redis": "^3.1.0",
 		"@signageos/service": "^1.2.0",
@@ -69,6 +69,7 @@
 		"@aws-sdk/client-s3": "3.489.0",
 		"@aws-sdk/lib-storage": "3.489.0",
 		"@aws-sdk/s3-request-presigner": "3.489.0",
+		"@google/genai": "2.13.0",
 		"aws-sdk": "^2.1472.0",
 		"mocha": "^3.1.2",
 		"mongoose": "^8.0.0",
@@ -89,6 +90,7 @@
 		"@aws-sdk/lib-storage": "3.489.0",
 		"@aws-sdk/s3-request-presigner": "3.489.0",
 		"@aws-sdk/types": "^3.489.0",
+		"@google/genai": "2.13.0",
 		"@faker-js/faker": "8.3.1",
 		"@istanbuljs/nyc-config-typescript": "1.0.2",
 		"@types/async-lock": "1.4.2",