ag-common 0.0.853 → 0.0.855

package/dist/api/helpers/google/apikey.js

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.blockKeyService = exports.getAvailableCombinations = void 0;
-const node_cache_1 = __importDefault(require("node-cache"));
 const common_1 = require("../../../common");
 const log_1 = require("../../../common/helpers/log");
 const truncate_1 = require("../../../common/helpers/string/truncate");
+const helpers_1 = require("../../../node/helpers");
 // Initialize NodeCache with 1 hour TTL for blocklisted key combinations
-const blocklist = new node_cache_1.default({ stdTTL: 3600 });
+const blocklist = new helpers_1.TypedNodeCache({ stdTTL: 3600 });
 // Helper to generate blocklist key
 const getBlocklistKey = (apiKey, service) => `${(0, truncate_1.truncate)(apiKey, 10)}_${service}`;
 // Helper to check if a key+service combination is blocklisted

package/dist/api/helpers/google/gemini.d.ts

@@ -1,4 +1,10 @@
 export type ModelPreference = 'quality' | 'fast' | undefined;
+export declare const geminiPromptImage: ({ prompt, urls, ident, prefer, }: {
+    prompt: string;
+    urls?: string[];
+    ident: string | undefined;
+    prefer?: ModelPreference;
+}) => Promise<string>;
 export declare const geminiPromptDirect: ({ prompt, images, ident, prefer, groundedSearch, }: {
     prompt: string;
     images?: {

package/dist/api/helpers/google/gemini.js

@@ -9,9 +9,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveGroundedUrl = exports.geminiPromptDirect = void 0;
+exports.resolveGroundedUrl = exports.geminiPromptDirect = exports.geminiPromptImage = void 0;
 const genai_1 = require("@google/genai");
+const array_1 = require("../../../common/helpers/array");
+const async_1 = require("../../../common/helpers/async");
 const log_1 = require("../../../common/helpers/log");
+const fetch_1 = require("../../../node/helpers/fetch");
 const apikey_1 = require("./apikey");
 let genAIs;
 // Available Gemini models
@@ -72,6 +75,24 @@ const getAvailableGeminiCombinations = (prefer) => {
     }
     return combinations;
 };
+const geminiPromptImage = (_a) => __awaiter(void 0, [_a], void 0, function* ({ prompt, urls, ident, prefer, }) {
+    let images = [];
+    if (urls && urls.length > 0) {
+        images = yield (0, async_1.asyncMap)(urls, (i) => (0, fetch_1.fetchToMemory)(i));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (images.find((a) => !a)) {
+        throw new Error('image not downloaded correctly');
+    }
+    const r = yield (0, exports.geminiPromptDirect)({
+        prompt,
+        images: images.filter(array_1.notEmpty),
+        ident,
+        prefer,
+    });
+    return r;
+});
+exports.geminiPromptImage = geminiPromptImage;
 const geminiPromptDirect = (_a) => __awaiter(void 0, [_a], void 0, function* ({ prompt, images = [], ident, prefer, groundedSearch = false, }) {
     var _b;
     const combinations = getAvailableGeminiCombinations(prefer);

package/dist/node/helpers/fetch.d.ts

@@ -6,3 +6,8 @@ export declare function fetchFile(p: {
     FILE_URL: string;
     FILE_PATH: string;
 }): Promise<void>;
+export declare function fetchToMemory(imageUrl: string): Promise<{
+    type: string;
+    arraybuffer: ArrayBuffer;
+} | undefined>;
+export declare function fetchExists(imageUrl: string): Promise<boolean>;

package/dist/node/helpers/fetch.js

@@ -13,7 +13,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchFile = fetchFile;
+exports.fetchToMemory = fetchToMemory;
+exports.fetchExists = fetchExists;
 const fs_1 = __importDefault(require("fs"));
+const withRetry_1 = require("../../api/helpers/withRetry");
+const log_1 = require("../../common/helpers/log");
+const headers_1 = require("./headers");
+const node_cache_1 = require("./node-cache");
 /**
  * download(fetch) file
  * @param p
@@ -45,3 +51,54 @@ function fetchFile(p) {
         }
     });
 }
+function fetchToMemory(imageUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Download the image
+            const response = yield fetch(imageUrl, { headers: (0, headers_1.getFetchHeaders)() });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            let type = response.headers.get('content-type') || 'image/jpeg';
+            if (type.includes('octet')) {
+                (0, log_1.debug)('forcing type to jpeg:' + imageUrl);
+                type = 'image/jpeg';
+            }
+            // Get the image data as an ArrayBuffer
+            const arraybuffer = yield response.arrayBuffer();
+            return { type, arraybuffer };
+        }
+        catch (e) {
+            const em = e;
+            (0, log_1.warn)('Error downloading image:', imageUrl, em.toString());
+            return undefined;
+        }
+    });
+}
+const imageExistsCache = new node_cache_1.TypedNodeCache({ stdTTL: 60 * 60 * 24 });
+function fetchExists(imageUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cached = imageExistsCache.get(imageUrl);
+        if (typeof cached === 'boolean') {
+            return cached;
+        }
+        const response = yield (0, withRetry_1.withRetry)(() => __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(imageUrl, {
+                method: 'HEAD',
+                headers: (0, headers_1.getFetchHeaders)(),
+            });
+            if (response.status === 200)
+                return true;
+            if (response.status === 404)
+                return false;
+            throw new Error(`Unexpected status: ${response.status}`);
+        }), 'imageExistsAtUrl');
+        if (response === false) {
+            imageExistsCache.set(imageUrl, false, 1);
+        }
+        else {
+            imageExistsCache.set(imageUrl, true);
+        }
+        return response;
+    });
+}

package/dist/node/helpers/headers.d.ts

@@ -0,0 +1,29 @@
+export declare const getFetchHeaders: (host?: string) => {
+    accept: string;
+    'accept-language': string;
+    connection: string;
+    dnt: string;
+    host: string;
+    'sec-fetch-dest': string;
+    'sec-fetch-mode': string;
+    'sec-fetch-site': string;
+    'user-agent': string;
+    'sec-ch-ua': string;
+    'sec-ch-ua-mobile': string;
+    'sec-ch-ua-platform': string;
+    'sec-fetch-user': string;
+    'upgrade-insecure-requests': string;
+    'viewport-width': string;
+    'viewport-height': string;
+    'sec-ch-ua-full-version-list': string;
+    'sec-ch-ua-arch': string;
+    'sec-ch-ua-bitness': string;
+    'sec-ch-ua-model': string;
+    'sec-ch-ua-platform-version': string;
+    'sec-ch-ua-wow64': string;
+    'device-memory': string;
+    downlink: string;
+    ect: string;
+    rtt: string;
+    'color-depth': string;
+};

package/dist/node/helpers/headers.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFetchHeaders = void 0;
+const languages = [
+    'en-AU,en;q=0.9,en-GB;q=0.8,en-US;q=0.7,cy;q=0.6,af;q=0.5,lb;q=0.4,hu;q=0.3,pt;q=0.2',
+];
+const browsers = [
+    {
+        name: 'Google Chrome',
+        version: '135',
+        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
+    },
+    {
+        name: 'Firefox',
+        version: '124',
+        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0',
+    },
+    {
+        name: 'Edge',
+        version: '122',
+        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0',
+    },
+];
+const platforms = ['Windows', 'Macintosh', 'Linux'];
+const getRandomItem = (array) => {
+    return array[Math.floor(Math.random() * array.length)];
+};
+// Add randomization to viewport dimensions
+const viewports = [
+    { width: 1920, height: 1080 },
+    { width: 1366, height: 768 },
+    { width: 1536, height: 864 },
+    { width: 1440, height: 900 },
+    { width: 1280, height: 720 },
+];
+const getFetchHeaders = (host) => {
+    const browser = getRandomItem(browsers);
+    const browserString = `"${browser.name}";v="${browser.version}", "Not-A.Brand";v="8", "Chromium";v="${browser.version}"`;
+    const viewport = getRandomItem(viewports);
+    const platform = getRandomItem(platforms);
+    const colorDepth = getRandomItem([24, 30, 48]);
+    const connection = getRandomItem(['4g', '5g', 'wifi']);
+    return {
+        accept: '*/*',
+        'accept-language': getRandomItem(languages),
+        connection: 'keep-alive',
+        dnt: '1',
+        host: host || '',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        'sec-fetch-site': 'same-origin',
+        'user-agent': browser.userAgent,
+        'sec-ch-ua': browserString,
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"Windows"',
+        'sec-fetch-user': '?1',
+        'upgrade-insecure-requests': '1',
+        'viewport-width': viewport.width.toString(),
+        'viewport-height': viewport.height.toString(),
+        'sec-ch-ua-full-version-list': browserString,
+        'sec-ch-ua-arch': `"${platform === 'Windows' ? 'x86' : 'arm'}"`,
+        'sec-ch-ua-bitness': '64',
+        'sec-ch-ua-model': '',
+        'sec-ch-ua-platform-version': platform === 'Windows' ? '"15.0.0"' : '"14.0.0"',
+        'sec-ch-ua-wow64': '?0',
+        'device-memory': getRandomItem(['4', '8', '16']),
+        downlink: getRandomItem(['1.5', '5.0', '10.0']),
+        ect: connection,
+        rtt: getRandomItem(['50', '100', '150']),
+        'color-depth': colorDepth.toString(),
+    };
+};
+exports.getFetchHeaders = getFetchHeaders;

package/dist/node/helpers/index.d.ts

@@ -1,2 +1,4 @@
 export * from './fetch';
 export * from './fs';
+export * from './headers';
+export * from './node-cache';

package/dist/node/helpers/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./fetch"), exports);
 __exportStar(require("./fs"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./node-cache"), exports);

package/dist/node/helpers/node-cache.d.ts

@@ -0,0 +1,71 @@
+import NodeCache from 'node-cache';
+export interface CacheOptions {
+    stdTTL?: number;
+    checkperiod?: number;
+    useClones?: boolean;
+    deleteOnExpire?: boolean;
+    enableLegacyCallbacks?: boolean;
+    maxKeys?: number;
+}
+export declare class TypedNodeCache<T = any> {
+    private cache;
+    constructor(options?: CacheOptions);
+    /**
+     * Normalizes the key to lowercase for case-insensitive operations
+     */
+    private normalizeKey;
+    /**
+     * Get a value from the cache
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set a value in the cache
+     */
+    set(key: string, value: T, ttl?: number): boolean;
+    /**
+     * Delete a key from the cache
+     */
+    del(key: string): number;
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key: string): boolean;
+    /**
+     * Get multiple values from the cache
+     */
+    mget(keys: string[]): {
+        [key: string]: T;
+    };
+    /**
+     * Set multiple values in the cache
+     */
+    mset(keyValuePairs: Array<{
+        key: string;
+        val: T;
+        ttl?: number;
+    }>): boolean;
+    /**
+     * Get all keys in the cache
+     */
+    keys(): string[];
+    /**
+     * Get cache statistics
+     */
+    getStats(): NodeCache.Stats;
+    /**
+     * Flush all data from the cache
+     */
+    flushAll(): void;
+    /**
+     * Close the cache and clear all timers
+     */
+    close(): void;
+    /**
+     * Get the TTL for a key
+     */
+    getTtl(key: string): number | undefined;
+    /**
+     * Set the TTL for a key
+     */
+    ttl(key: string, ttl: number): boolean;
+}

package/dist/node/helpers/node-cache.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedNodeCache = void 0;
+const node_cache_1 = __importDefault(require("node-cache"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class TypedNodeCache {
+    constructor(options = {}) {
+        this.cache = new node_cache_1.default(Object.assign({ stdTTL: 3600, checkperiod: 120 }, options));
+    }
+    /**
+     * Normalizes the key to lowercase for case-insensitive operations
+     */
+    normalizeKey(key) {
+        return key.toLowerCase();
+    }
+    /**
+     * Get a value from the cache
+     */
+    get(key) {
+        return this.cache.get(this.normalizeKey(key));
+    }
+    /**
+     * Set a value in the cache
+     */
+    set(key, value, ttl) {
+        if (ttl !== undefined) {
+            return this.cache.set(this.normalizeKey(key), value, ttl);
+        }
+        return this.cache.set(this.normalizeKey(key), value);
+    }
+    /**
+     * Delete a key from the cache
+     */
+    del(key) {
+        return this.cache.del(this.normalizeKey(key));
+    }
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key) {
+        return this.cache.has(this.normalizeKey(key));
+    }
+    /**
+     * Get multiple values from the cache
+     */
+    mget(keys) {
+        const normalizedKeys = keys.map((key) => this.normalizeKey(key));
+        return this.cache.mget(normalizedKeys);
+    }
+    /**
+     * Set multiple values in the cache
+     */
+    mset(keyValuePairs) {
+        const normalizedPairs = keyValuePairs.map((pair) => (Object.assign(Object.assign({}, pair), { key: this.normalizeKey(pair.key) })));
+        return this.cache.mset(normalizedPairs);
+    }
+    /**
+     * Get all keys in the cache
+     */
+    keys() {
+        return this.cache.keys();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Flush all data from the cache
+     */
+    flushAll() {
+        this.cache.flushAll();
+    }
+    /**
+     * Close the cache and clear all timers
+     */
+    close() {
+        this.cache.close();
+    }
+    /**
+     * Get the TTL for a key
+     */
+    getTtl(key) {
+        return this.cache.getTtl(this.normalizeKey(key));
+    }
+    /**
+     * Set the TTL for a key
+     */
+    ttl(key, ttl) {
+        return this.cache.ttl(this.normalizeKey(key), ttl);
+    }
+}
+exports.TypedNodeCache = TypedNodeCache;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.853",
+  "version": "0.0.855",
   "name": "ag-common",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",