@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/llms/baseChatBot.js

@@ -0,0 +1,183 @@
+import { OpenAI } from "openai";
+const DEBUG = false;
+const url = process.env.REDIS_MEMORY_URL ||
+    process.env.REDIS_URL ||
+    "redis://localhost:6379";
+const tlsOptions = url.startsWith("rediss://")
+    ? { rejectUnauthorized: false }
+    : undefined;
+export class YpBaseChatBot {
+    destroy() {
+        this.wsClientSocket = undefined;
+    }
+    loadMemory() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                console.log("loadMemoryWithOwnership loadMemory: redisKey: ", this.redisKey);
+                const memoryString = await this.redis.get(this.redisKey);
+                if (memoryString) {
+                    const memory = JSON.parse(memoryString);
+                    resolve(memory);
+                }
+                else {
+                    console.error("loadMemoryWithOwnership loadMemory: no memory found");
+                    resolve(undefined);
+                }
+            }
+            catch (error) {
+                console.error("loadMemoryWithOwnership loadMemory: Can't load memory from redis", error);
+                resolve(undefined);
+            }
+        });
+    }
+    constructor(wsClientId, wsClients, redisConnection, redisKey) {
+        this.temperature = 0.7;
+        this.maxTokens = 16000;
+        this.llmModel = "gpt-4o";
+        this.persistMemory = false;
+        this.redis = redisConnection;
+        this.redisKey = redisKey;
+        this.wsClientId = wsClientId;
+        this.wsClientSocket = wsClients.get(this.wsClientId);
+        this.wsClients = wsClients;
+        console.log(`WebSockets: BaseChatBot constructor for ${this.wsClientId}`);
+        if (!this.wsClientSocket) {
+            console.error(`WebSockets: WS Client ${this.wsClientId} not found in streamWebSocketResponses`);
+        }
+        this.openaiClient = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+        });
+    }
+    async saveMemory() {
+        if (this.memory) {
+            try {
+                await this.redis.set(this.redisKey, JSON.stringify(this.memory));
+                console.log(`Saved memory to redis: ${this.redisKey}`);
+            }
+            catch (error) {
+                console.log("Can't save memory to redis", error);
+            }
+        }
+        else {
+            console.error("Memory is not initialized");
+        }
+    }
+    renderSystemPrompt() {
+        return `Please tell the user to replace this system prompt in a fun and friendly way. Encourage them to have a nice day. Lots of emojis`;
+    }
+    sendAgentStart(name, hasNoStreaming = true) {
+        const botMessage = {
+            sender: "assistant",
+            type: "agentStart",
+            data: {
+                name: name,
+                noStreaming: hasNoStreaming,
+            },
+        };
+        this.wsClientSocket.send(JSON.stringify(botMessage));
+    }
+    sendAgentCompleted(name, lastAgent = false, error = undefined) {
+        const botMessage = {
+            sender: "assistant",
+            type: "agentCompleted",
+            data: {
+                name: name,
+                results: {
+                    isValid: true,
+                    validationErrors: error,
+                    lastAgent: lastAgent,
+                },
+            },
+        };
+        this.wsClientSocket.send(JSON.stringify(botMessage));
+    }
+    sendAgentUpdate(message) {
+        const botMessage = {
+            sender: "assistant",
+            type: "agentUpdated",
+            message: message,
+        };
+        this.wsClientSocket.send(JSON.stringify(botMessage));
+    }
+    sendToClient(sender, message, type = "stream", uniqueToken = undefined, hiddenContextMessage = false) {
+        try {
+            if (process.env.WS_DEBUG) {
+                console.log(`sendToClient: ${JSON.stringify({ sender, type, message, hiddenContextMessage }, null, 2)}`);
+            }
+            this.wsClientSocket.send(JSON.stringify({
+                sender,
+                type: type,
+                message: type === "html" ? undefined : message,
+                html: type === "html" ? message : undefined,
+                hiddenContextMessage,
+                uniqueToken,
+                avatarUrl: sender === "assistant" ? this.currentAssistantAvatarUrl : undefined,
+            }));
+            this.lastSentToUserAt = new Date();
+        }
+        catch (error) {
+            console.error("Can't send message to client", error);
+        }
+    }
+    async streamWebSocketResponses(stream) {
+        return new Promise(async (resolve, reject) => {
+            this.sendToClient("assistant", "", "start", this.currentAssistantAvatarUrl);
+            try {
+                let botMessage = "";
+                for await (const part of stream) {
+                    this.sendToClient("assistant", part.choices[0].delta.content);
+                    botMessage += part.choices[0].delta.content;
+                    if (part.choices[0].finish_reason == "stop") {
+                        this.memory.chatLog.push({
+                            sender: "assistant",
+                            message: botMessage,
+                            type: "message",
+                        });
+                        await this.saveMemoryIfNeeded();
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+                this.sendToClient("assistant", "There has been an error, please retry", "error");
+                reject();
+            }
+            finally {
+                this.sendToClient("assistant", "", "end");
+            }
+            resolve();
+        });
+    }
+    async saveMemoryIfNeeded() {
+        if (this.persistMemory) {
+            await this.saveMemory();
+        }
+    }
+    async setChatLog(chatLog) {
+        this.memory.chatLog = chatLog;
+        await this.saveMemoryIfNeeded();
+    }
+    async conversation(chatLog) {
+        this.setChatLog(chatLog);
+        let messages = chatLog.map((message) => {
+            return {
+                role: message.sender,
+                content: message.message,
+            };
+        });
+        const systemMessage = {
+            role: "system",
+            content: this.renderSystemPrompt(),
+        };
+        messages.unshift(systemMessage);
+        const stream = await this.openaiClient.chat.completions.create({
+            model: this.llmModel,
+            messages,
+            max_tokens: this.maxTokens,
+            temperature: this.temperature,
+            stream: true,
+        });
+        this.streamWebSocketResponses(stream);
+    }
+}
+YpBaseChatBot.redisMemoryKeyPrefix = "yp-chatbot-memory-v4";

package/dist/active-citizen/llms/imageGeneration/chatGptImageGenerator.js

@@ -0,0 +1,56 @@
+// chatGptImageGenerator.ts
+import { OpenAI } from "openai";
+export class ChatGptImageGenerator {
+    constructor(openAiKey) {
+        this.maxRetryCount = 3;
+        // the SDK will fall back to process.env.OPENAI_API_KEY if nothing is passed
+        this.openAiKey = openAiKey;
+    }
+    /**
+     * Generates an image URL from a prompt using OpenAI’s gpt-image-1 model.
+     * The returned link remains live for ~60 minutes – be sure to download
+     * or cache it right away in the calling service.
+     */
+    async generateImageUrl(prompt, type = "logo") {
+        const client = new OpenAI({ apiKey: this.openAiKey });
+        // Pick a sensible canvas size from the image type
+        let size = "1536x1024";
+        if (type === "icon")
+            size = "1024x1024";
+        else if (type === "other")
+            size = "1536x1024";
+        const finalPrompt = `
+    ${prompt}
+
+    Instruction: Create a high quality logo like image for the users project and follow their style instructions. \
+    Do not add text to the images unless asked in the style instructions.
+    `;
+        let retryCount = 0;
+        while (retryCount < this.maxRetryCount) {
+            try {
+                const res = await client.images.generate({
+                    model: "gpt-image-1",
+                    prompt: finalPrompt,
+                    quality: "medium",
+                    n: 1,
+                    size
+                });
+                const url = res?.data?.[0]?.url;
+                if (url)
+                    return url;
+                throw new Error("No URL returned");
+            }
+            catch (err) {
+                retryCount += 1;
+                if (retryCount >= this.maxRetryCount) {
+                    console.error(`ChatGptImageGenerator failed after ${retryCount} attempts`, err);
+                    return undefined;
+                }
+                // Exponential back-off – starts at 5 s and grows +5 s each retry
+                await new Promise((r) => setTimeout(r, 5000 + retryCount * 5000));
+            }
+        }
+        return undefined;
+    }
+}
+export default ChatGptImageGenerator;

package/dist/active-citizen/llms/imageGeneration/collectionImageGenerator.js

@@ -0,0 +1,109 @@
+import path from "path";
+import fs from "fs";
+import { v4 as uuidv4 } from "uuid";
+import axios from "axios";
+import { FluxImageGenerator } from "./fluxImageGenerator.js";
+import { DalleImageGenerator } from "./dalleImageGenerator.js";
+import { ImageProcessorService } from "./imageProcessorService.js";
+import { S3Service } from "./s3Service.js";
+// Suppose these come from your codebase
+import models from "../../../models/index.cjs";
+import { ImagenImageGenerator } from "./imagenImageGenerator.js";
+import { ChatGptImageGenerator } from "./chatGptImageGenerator.js";
+// For reference, in your code:
+const dbModels = models;
+const Image = dbModels.Image;
+const AcBackgroundJob = dbModels.AcBackgroundJob;
+const disableFlux = false;
+const useImagen = false;
+export class CollectionImageGenerator {
+    constructor() {
+        this.s3Service = new S3Service(process.env.CLOUDFLARE_API_KEY, process.env.CLOUDFLARE_ZONE_ID);
+        this.imageProcessorService = new ImageProcessorService();
+        // Initialize generators
+        if (!disableFlux &&
+            process.env.REPLICATE_API_TOKEN &&
+            process.env.FLUX_PRO_MODEL_NAME) {
+            this.fluxImageGenerator = new FluxImageGenerator(process.env.REPLICATE_API_TOKEN, process.env.FLUX_PRO_MODEL_NAME);
+        }
+        this.dalleImageGenerator = new DalleImageGenerator(process.env.AZURE_OPENAI_API_BASE, process.env.AZURE_OPENAI_API_KEY, process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME, process.env.OPENAI_API_KEY);
+        this.chatGptImageGenerator = new ChatGptImageGenerator(process.env.OPENAI_API_KEY);
+        if (useImagen && process.env.GOOGLE_CLOUD_PROJECT_ID) {
+            this.imagenImageGenerator = new ImagenImageGenerator(this.s3Service);
+        }
+    }
+    /**
+     * Orchestrates image generation (via Flux or DALL·E), downloads that image,
+     * uploads it to S3, and saves a record in the DB.
+     */
+    async createCollectionImage(workPackage) {
+        return new Promise(async (resolve, reject) => {
+            let newImageUrl;
+            const imageFilePath = path.join("/tmp", `${uuidv4()}.png`);
+            const s3ImagePath = `ypGenAi/${workPackage.collectionType}/${workPackage.collectionId}/${uuidv4()}.png`;
+            try {
+                let imageGenerator;
+                // Decide which generator to use
+                if (this.imagenImageGenerator) {
+                    imageGenerator = this.imagenImageGenerator;
+                    console.info("Using ImagenImageGenerator");
+                }
+                else if (this.fluxImageGenerator) {
+                    imageGenerator = this.fluxImageGenerator;
+                    console.info("Using FluxImageGenerator");
+                }
+                else if (process.env.USE_CHATGPT_IMAGE_GENERATOR) {
+                    imageGenerator = this.chatGptImageGenerator;
+                    console.info("Using ChatGptImageGenerator");
+                }
+                else {
+                    imageGenerator = this.dalleImageGenerator;
+                    console.info("Using DalleImageGenerator");
+                }
+                // 1) Generate image
+                const imageUrl = await imageGenerator.generateImageUrl(workPackage.prompt, workPackage.imageType);
+                if (!imageUrl) {
+                    return reject("Error getting image URL from prompt.");
+                }
+                if (useImagen && this.imagenImageGenerator) {
+                    newImageUrl = imageUrl;
+                }
+                else {
+                    // 2) Download image to temporary location
+                    await this.imageProcessorService.downloadImage(imageUrl, imageFilePath, axios);
+                    console.debug(fs.existsSync(imageFilePath)
+                        ? "File downloaded successfully."
+                        : "File download failed.");
+                    // (Optional) If you want to resize the image before upload:
+                    // const resizedPath = await this.imageProcessorService.resizeImage(imageFilePath, 1024, 1024);
+                    // Upload the `resizedPath` instead of `imageFilePath`
+                    // 3) Upload image to S3
+                    await this.s3Service.uploadImageToS3(process.env.S3_BUCKET, imageFilePath, s3ImagePath);
+                    // 4) Construct a public URL (optionally going through Cloudflare)
+                    if (process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN) {
+                        newImageUrl = `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${s3ImagePath}`;
+                    }
+                    else {
+                        newImageUrl = `https://${process.env
+                            .S3_BUCKET}.s3.amazonaws.com/${s3ImagePath}`;
+                    }
+                }
+                // 5) Save record in DB
+                const formats = JSON.stringify([newImageUrl]);
+                const imageRecord = await Image.build({
+                    user_id: workPackage.userId,
+                    s3_bucket_name: process.env.S3_BUCKET,
+                    original_filename: "n/a",
+                    formats,
+                    user_agent: "AI worker",
+                    ip_address: "127.0.0.1",
+                });
+                await imageRecord.save();
+                resolve({ imageId: imageRecord.id, imageUrl: newImageUrl });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}

package/dist/active-citizen/llms/imageGeneration/dalleImageGenerator.js

@@ -0,0 +1,84 @@
+import { AzureOpenAI, OpenAI } from "openai";
+export class DalleImageGenerator {
+    constructor(azureOpenaAiBase, azureOpenAiApiKey, azureDalleDeployment, openAiKey) {
+        this.maxRetryCount = 3;
+        this.azureOpenaAiBase = azureOpenaAiBase;
+        this.azureOpenAiApiKey = azureOpenAiApiKey;
+        this.azureDalleDeployment = azureDalleDeployment;
+        this.openAiKey = openAiKey;
+    }
+    async generateImageUrl(prompt, type = "logo") {
+        let client;
+        let result;
+        let retryCount = 0;
+        let retrying = true;
+        // Decide which client to instantiate (Azure vs. standard OpenAI)
+        if (this.azureOpenaAiBase && this.azureOpenAiApiKey && this.azureDalleDeployment) {
+            client = new AzureOpenAI({
+                apiKey: this.azureOpenAiApiKey,
+                endpoint: this.azureOpenaAiBase,
+                deployment: this.azureDalleDeployment,
+                apiVersion: "2024-10-21",
+            });
+        }
+        else {
+            // fallback to standard OpenAI
+            client = new OpenAI({
+                apiKey: this.openAiKey,
+            });
+        }
+        // Decide on image dimensions
+        let size = "1792x1024";
+        if (type === "logo") {
+            size = "1792x1024";
+        }
+        else if (type === "icon") {
+            size = "1024x1024";
+        }
+        const modelQuality = "standard";
+        while (retrying && retryCount < this.maxRetryCount) {
+            try {
+                // If using Azure OpenAI
+                if (this.azureOpenaAiBase && this.azureOpenAiApiKey && this.azureDalleDeployment) {
+                    result = await client.images.generate({
+                        prompt,
+                        n: 1,
+                        size,
+                        quality: modelQuality,
+                    });
+                }
+                else {
+                    // Standard OpenAI
+                    result = await client.images.generate({
+                        model: "dall-e-3",
+                        prompt,
+                        n: 1,
+                        size,
+                        quality: modelQuality,
+                    });
+                }
+                if (result) {
+                    retrying = false;
+                }
+                else {
+                    console.debug("Result: NONE");
+                }
+            }
+            catch (error) {
+                console.warn("Error generating image with DALL·E, retrying...");
+                console.warn(error.stack);
+                retryCount++;
+                const sleepingFor = 5000 + retryCount * 10000;
+                console.debug(`Sleeping for ${sleepingFor} milliseconds`);
+                await new Promise((resolve) => setTimeout(resolve, sleepingFor));
+            }
+        }
+        if (result && result.data && result.data[0].url) {
+            return result.data[0].url;
+        }
+        else {
+            console.error(`Error generating image after ${retryCount} retries`);
+            return undefined;
+        }
+    }
+}

package/dist/active-citizen/llms/imageGeneration/fluxImageGenerator.js

@@ -0,0 +1,49 @@
+import Replicate from "replicate";
+export class FluxImageGenerator {
+    constructor(replicateApiKey, fluxProModelName) {
+        this.replicateApiKey = replicateApiKey;
+        this.fluxProModelName = fluxProModelName;
+        this.maxRetryCount = 3;
+        this.replicate = new Replicate({ auth: replicateApiKey });
+    }
+    async generateImageUrl(prompt, type = "logo") {
+        let retryCount = 0;
+        let retrying = true;
+        let result;
+        // Configure the input to replicate’s model
+        const input = { prompt };
+        // Assign aspect ratio depending on type
+        if (type === "logo") {
+            input.aspect_ratio = "16:9";
+        }
+        else if (type === "icon") {
+            input.aspect_ratio = "1:1";
+        }
+        else {
+            input.aspect_ratio = "16:9";
+        }
+        while (retrying && retryCount < this.maxRetryCount) {
+            try {
+                result = await this.replicate.run(this.fluxProModelName, {
+                    input,
+                });
+                if (result) {
+                    retrying = false;
+                    return result; // typically a single URL
+                }
+            }
+            catch (error) {
+                console.warn("Error generating image with Flux, retrying...");
+                console.warn(error.stack);
+                retryCount++;
+                const sleepingFor = 5000 + retryCount * 10000;
+                console.debug(`Sleeping for ${sleepingFor} milliseconds`);
+                await new Promise((resolve) => setTimeout(resolve, sleepingFor));
+            }
+        }
+        if (!result) {
+            console.error(`Error generating image after ${retryCount} retries`);
+        }
+        return undefined;
+    }
+}

package/dist/active-citizen/llms/imageGeneration/imageProcessorService.js

@@ -0,0 +1,64 @@
+import fs from "fs";
+import path from "path";
+import sharp from "sharp";
+import { v4 as uuidv4 } from "uuid";
+export class ImageProcessorService {
+    constructor() {
+        this.validFormats = ["jpeg", "png", "webp", "gif", "tiff", "avif", "svg"];
+    }
+    /**
+     * Downloads an image from a given URL into the specified filepath.
+     */
+    async downloadImage(imageUrl, imageFilePath, axiosInstance) {
+        const response = await axiosInstance({
+            method: "GET",
+            url: imageUrl,
+            responseType: "stream",
+        });
+        const writer = fs.createWriteStream(imageFilePath);
+        response.data.pipe(writer);
+        return new Promise((resolve, reject) => {
+            writer.on("finish", () => resolve());
+            writer.on("error", reject);
+        });
+    }
+    /**
+     * Resizes an image to given dimensions (width x height).
+     * If the image is smaller, it won't be enlarged.
+     */
+    async resizeImage(imagePath, width, height) {
+        const resizedImageFilePath = path.join("/tmp", `${uuidv4()}.png`);
+        try {
+            // 1) Initialize Sharp instance
+            const image = sharp(imagePath).rotate(); // rotate fixes orientation from EXIF
+            // 2) Read metadata to validate format
+            const metadata = await image.metadata();
+            if (!metadata.format || !this.validFormats.includes(metadata.format)) {
+                throw new Error(`Unsupported format: ${metadata.format} (expected one of ${this.validFormats.join(", ")})`);
+            }
+            // 3) Resize + convert
+            await image
+                .resize({
+                width,
+                height,
+                fit: "inside",
+                withoutEnlargement: true,
+            })
+                .toFormat("png", {
+                quality: 90,
+                progressive: true,
+            })
+                .toFile(resizedImageFilePath);
+            // 4) Remove the original file
+            fs.unlinkSync(imagePath);
+            return resizedImageFilePath;
+        }
+        catch (err) {
+            console.error("Error resizing image:", err);
+            if (fs.existsSync(resizedImageFilePath)) {
+                fs.unlinkSync(resizedImageFilePath);
+            }
+            throw err;
+        }
+    }
+}

package/dist/active-citizen/llms/imageGeneration/imagenImageGenerator.js

@@ -0,0 +1,107 @@
+import fs from "fs";
+import path from "path";
+import { v4 as uuidv4 } from "uuid";
+import { PredictionServiceClient } from "@google-cloud/aiplatform";
+import { helpers } from "@google-cloud/aiplatform";
+export class ImagenImageGenerator {
+    constructor(s3Service) {
+        this.s3Service = s3Service;
+        this.maxRetryCount = 3;
+        // Pull these from your environment or config
+        this.projectId = process.env.GOOGLE_CLOUD_PROJECT_ID || "";
+        this.location = process.env.GOOGLE_CLOUD_IMAGEN_LOCATION || "us-east1";
+        // Matches the official endpoint for Imagen v3.0:
+        this.endpoint = `projects/${this.projectId}/locations/${this.location}/publishers/google/models/imagen-3.0-generate-002`;
+        this.s3Bucket = process.env.S3_BUCKET || "";
+        if (!this.projectId) {
+            console.warn("Warning: GOOGLE_CLOUD_PROJECT_ID is not set. Vertex AI calls may fail.");
+        }
+        if (!this.s3Bucket) {
+            console.warn("Warning: S3_BUCKET is not set. Image upload may fail.");
+        }
+    }
+    /**
+     * Generates an image from a text prompt using Vertex AI Imagen
+     * and returns a public S3 URL to the uploaded image.
+     */
+    async generateImageUrl(prompt, type = "logo") {
+        let retryCount = 0;
+        let finalUrl;
+        // Configure the API endpoint for Vertex AI
+        const clientOptions = {
+            apiEndpoint: `${this.location}-aiplatform.googleapis.com`,
+        };
+        const predictionServiceClient = new PredictionServiceClient(clientOptions);
+        while (retryCount < this.maxRetryCount && !finalUrl) {
+            try {
+                // 1) Prepare the prompt and parameters for Imagen
+                const promptText = {
+                    prompt: prompt, // The text prompt describing what you want to see
+                };
+                const instanceValue = helpers.toValue(promptText);
+                const instances = [instanceValue];
+                const parameter = {
+                    sampleCount: 1,
+                    // You can tweak these settings to your needs:
+                    // seed: 100,
+                    // addWatermark: false,
+                    aspectRatio: "16:9",
+                    safetyFilterLevel: "block_some",
+                    personGeneration: "allow_adult",
+                };
+                const parameters = helpers.toValue(parameter);
+                // 2) Build the predict request
+                const request = {
+                    endpoint: this.endpoint,
+                    instances,
+                    parameters,
+                };
+                // 3) Make the API call
+                //@ts-ignore
+                const [response] = await predictionServiceClient.predict(request);
+                const predictions = response.predictions;
+                if (!predictions || predictions.length === 0) {
+                    console.warn("No image was generated. Check the request parameters and prompt.");
+                }
+                else {
+                    // 4) Extract base64 data from the first prediction
+                    const prediction = predictions[0];
+                    const b64Data = prediction.structValue?.fields?.bytesBase64Encoded?.stringValue;
+                    if (!b64Data) {
+                        throw new Error("Prediction did not contain base64 image data.");
+                    }
+                    // 5) Decode and write to a temporary file
+                    const buff = Buffer.from(b64Data, "base64");
+                    const tmpFilePath = path.join("/tmp", `${uuidv4()}.png`);
+                    fs.writeFileSync(tmpFilePath, buff);
+                    // 6) Upload the image to S3
+                    const s3Key = `imagenAi/${uuidv4()}.png`;
+                    await this.s3Service.uploadImageToS3(this.s3Bucket, tmpFilePath, s3Key);
+                    // 7) Construct a public URL (optionally using Cloudflare)
+                    if (process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN) {
+                        finalUrl = `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${s3Key}`;
+                    }
+                    else {
+                        finalUrl = `https://${this.s3Bucket}.s3.amazonaws.com/${s3Key}`;
+                    }
+                }
+            }
+            catch (error) {
+                console.warn("Error generating image with Vertex AI Imagen. Will retry...");
+                console.warn(error?.message || error);
+            }
+            // Retry logic
+            if (!finalUrl) {
+                retryCount++;
+                const sleepingFor = 5000 + retryCount * 10000;
+                console.debug(`Sleeping for ${sleepingFor} ms before retry #${retryCount}...`);
+                await new Promise((resolve) => setTimeout(resolve, sleepingFor));
+            }
+        }
+        if (!finalUrl) {
+            console.error(`Failed to generate Imagen after ${retryCount} retries.`);
+            return undefined;
+        }
+        return finalUrl;
+    }
+}