@xuda.io/ai_module 1.1.3612 → 1.1.3613

package/index.mjs

@@ -5689,3 +5689,253 @@ const delete_depended_chats = async function (uid, reference_id) {
     await delete_ai_chat({ conversation_id: doc._id, uid });
   }
 };
+
+export const create_ai_agent_image = async function (req, job_id, headers) {
+  async function normalizeBase64To1024(base64Image) {
+    const inputBuffer = Buffer.from(base64Image, 'base64');
+
+    const normalizedBuffer = await sharp(inputBuffer)
+      .resize(1024, 1024, {
+        fit: 'contain', // Preserve aspect ratio, fit within 211x211
+        background: { r: 0, g: 0, b: 0, alpha: 0 }, // Transparent background for padding
+      })
+      .png({
+        quality: 100,
+        compressionLevel: 9,
+        force: true,
+      })
+      .toBuffer();
+
+    return normalizedBuffer.toString('base64'); // Return normalized base64 string
+  }
+
+  async function hasTransparentBackground(filePath) {
+    const image = sharp(filePath);
+    const metadata = await image.metadata();
+
+    // If the image doesn't have an alpha channel at all → no transparency possible
+    if (!metadata.hasAlpha) {
+      return false;
+    }
+
+    // For images with alpha channel, check if any pixel actually has alpha < 255
+    const { data, info } = await image.raw().toBuffer({ resolveWithObject: true });
+
+    // Determine position of alpha channel based on number of channels
+    const channels = info.channels; // 2 (grayscale+alpha), 4 (RGBA), etc.
+    const alphaOffset = channels === 2 ? 1 : channels === 4 ? 3 : -1;
+
+    if (alphaOffset === -1) {
+      // Unusual channel count – be conservative and assume it might have transparency
+      return true;
+    }
+
+    for (let i = alphaOffset; i < data.length; i += channels) {
+      if (data[i] < 255) {
+        return true; // Found at least one transparent/semi-transparent pixel
+      }
+    }
+
+    return false; // Has alpha channel but all pixels are fully opaque
+  }
+
+  async function imageToPngBlob(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    let buffer;
+
+    let is_transparent = false;
+    if (ext === '.png') {
+      buffer = await fs.promises.readFile(filePath);
+      is_transparent = await hasTransparentBackground(filePath);
+    } else {
+      console.log(`Converting ${path.basename(filePath)} to PNG...`);
+      buffer = await sharp(filePath).png({ quality: 100, compressionLevel: 9, force: true }).toBuffer();
+    }
+
+    // Create a Blob with correct MIME type
+
+    return { is_transparent, image_blob: new Blob([buffer], { type: 'image/png' }) };
+  }
+
+  const detect_real_person_in_image = async function (base64) {
+    const ret = await submit_chat_gpt_prompt({
+      model: 'gpt-5-nano',
+      prompt: [
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'input_text',
+              text: `detect if a postrate of real person shown in the picture `,
+            },
+            {
+              type: 'input_image',
+              image_url: `data:image/png;base64,${base64}`,
+            },
+          ],
+        },
+      ],
+      response_format: z.object({
+        is_real_person_in_picture: z.boolean().describe('if a postrate of real person in the picture return true otherwise return false'),
+      }),
+    });
+
+    const res = JSON5.parse(ret.data);
+    return res?.is_real_person_in_picture;
+  };
+
+  const { url, uid, account_obj, prompt } = req;
+
+  try {
+    if (!url) {
+      throw new Error('No URL provided in request');
+    }
+
+    // 3. Download the image to a Buffer
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch image URL: ${res.status} ${res.statusText}`);
+    }
+
+    const arrayBuffer = await res.arrayBuffer();
+    const imageBuffer = Buffer.from(arrayBuffer);
+
+    const tempDir = os.tmpdir();
+    const uniqueId = Date.now() + '_' + Math.random().toString(36).substring(7);
+
+    const inputExt = path.extname(url) || '.jpg';
+    const tempInputPath = path.join(tempDir, `input_${uniqueId}${inputExt}`);
+    const tempOutputPath = path.join(tempDir, `output_${uniqueId}.png`); // Output is always PNG (transparent)
+
+    // 5. Write the downloaded image to disk
+    fs.writeFileSync(tempInputPath, imageBuffer);
+    /////////////////////////////////
+
+    const imageFiles = [tempInputPath];
+
+    const images = await Promise.all(
+      imageFiles.map(async (filePath) => {
+        const img_ret = await imageToPngBlob(filePath);
+        const blob = img_ret.image_blob;
+
+        // OpenAI expects a filename for logging/debugging
+        const filename = path.basename(filePath, path.extname(filePath)) + '.png';
+        blob.name = filename; // Optional but helpful
+        // @ts-ignore – name is allowed in Node 20+
+        blob.lastModified = Date.now();
+
+        return { is_transparent: img_ret.is_transparent, image_blob: blob };
+      }),
+    );
+
+    let imageBase64;
+    let avatar_source = '';
+
+    //////////////////
+    imageBase64 = Buffer.from(await images[0].image_blob.arrayBuffer()).toString('base64');
+    if (account_obj.account_info.account_type === 'business') {
+      // create avatar from logo - BUSINESS
+      const { bio, business_name, country, mainCategory, subCategory } = account_obj.account_info;
+      // const ai_avatar_response = await client.images.edit({
+      //   model: 'chatgpt-image-latest',
+      //   image: images[0].image_blob, // only one image allowed
+      //   prompt: `Generate a realistic fictional portrait wearing a hat. The portrait should be centered, head-and-shoulders only, on a transparent background. Place the provided logo on the hat, and ensure the subject is large enough to fill most of the frame. Use the supplied name, country, and context to guide the character’s appearance.
+      // Context: ${JSON.stringify({ bio, business_name, country, mainCategory, subCategory })}`,
+      //   background: 'transparent',
+      // });
+      const ai_avatar_response = await client.images.edit({
+        model: 'chatgpt-image-latest',
+        image: images[0].image_blob, //base photo
+        prompt: `Create a transparent PNG profile image for a business account featuring  building branded as ${business_name}. 
+          Display the attached logo clearly as prominent exterior signage. 
+          The building’s architecture and overall atmosphere should reflect the nature of the business, aligning with ${mainCategory} and ${subCategory}. 
+          Use the provided bio (${bio}) to understand the company’s focus and personality, and adapt the architectural style to match the ${country} country’s local design language. Select an appropriate building type for the specific business category, and present a contemporary, 
+          creative office environment with a strong, recognizable brand identity. The background should be fully removed, remove trees,clouds,sky or any landscape objects`,
+        background: 'transparent',
+      });
+      imageBase64 = ai_avatar_response.data[0].b64_json;
+      avatar_source = 'fictional';
+    } else {
+      const create_avatar_from_pic = async function () {
+        const { first_name, last_name, bio, country, mainCategory, subCategory } = account_obj.account_info;
+        const ai_avatar_response = await client.images.edit({
+          model: 'chatgpt-image-latest',
+          image: images[0].image_blob,
+
+          prompt: `Completely remove the background, enhance and color-correct the subject, and return only a centered head-and-shoulders portrait facing the camera. Add extra top margin, include no labels or text, and export the result as a clean transparent PNG.
+             Ensure the subject is large enough to fill most of the frame. Use the supplied name, country, and context to guide the character’s appearance.
+            Context: ${JSON.stringify({ first_name, last_name, bio, country, mainCategory, subCategory })}`,
+          background: 'transparent',
+        });
+        imageBase64 = ai_avatar_response.data[0].b64_json;
+        avatar_source = 'ai profile';
+      };
+      const create_fictional_avatar = async function () {
+        const { first_name, last_name, bio, country, mainCategory, subCategory } = account_obj.account_info;
+
+        const prompt = `analyze the the person info :  ${JSON.stringify({ first_name, last_name, bio, country, mainCategory, subCategory })} 
+            and create realistic fictional profile picture transparent background ,person in the center of the picture return only a centered head-and-shoulders portrait facing the camera. include no labels or text add top margin the person should cover the whole picture`;
+
+        imageBase64 = await create_image(prompt, undefined, undefined, 1);
+        avatar_source = 'fictional';
+      };
+      // personal account
+      const is_real_person_in_picture = await detect_real_person_in_image(imageBase64);
+      if (is_real_person_in_picture) {
+        if (images[0].is_transparent) {
+          // keep the original
+          imageBase64 = Buffer.from(await images[0].image_blob.arrayBuffer()).toString('base64');
+          avatar_source = 'authentic profile';
+        } else {
+          // create avatar from profile picture
+          await create_avatar_from_pic();
+        }
+      } else {
+        // create avatar from profile picture
+        await create_fictional_avatar();
+      }
+    }
+
+    console.log('Normalizing final avatar to 1024 with transparent padding...');
+    imageBase64 = await normalizeBase64To1024(imageBase64);
+
+    const outputBuffer = Buffer.from(imageBase64, 'base64');
+    const outputPath = tempOutputPath;
+    await fs.promises.writeFile(outputPath, outputBuffer);
+
+    console.log('Success! Saved →', outputPath);
+
+    const ext = 'png';
+    const originalname = `avatar_${account_obj?.account_info?.email || account_obj._id}.${ext}`;
+
+    const file_obj = {
+      originalname,
+      path: outputPath,
+      mimetype: `image/${ext}`,
+    };
+
+    const drive_ret = await drive_module.upload_drive_file_user({ uid, path: '/Profile Images' }, job_id, headers, file_obj);
+
+    if (drive_ret.code > 0) {
+      let db_doc = await db_module.get_couch_doc_native('xuda_accounts', account_obj._id);
+      db_doc.account_info.profile_avatar = drive_ret.data.file_url;
+      db_doc.account_info.profile_avatar_obj == drive_ret.data;
+      db_doc.account_info.avatar_source = avatar_source;
+      db_doc.image_request_ts = Date.now();
+      const save_ret = await db_module.save_couch_doc_native('xuda_accounts', db_doc);
+      console.log(save_ret);
+      await update_profile_avatar_status(uid, 3);
+      return save_ret;
+      // account_module.update_contacts_with_account_changes(db_doc._id, ['profile_avatar']);
+    } else {
+      throw new Error(drive_ret.data);
+    }
+  } catch (error) {
+    await update_profile_avatar_status(uid, 1);
+    console.error('Error:', error.message);
+    if (error.response?.data) {
+      console.error('OpenAI API response:', error.response.data);
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.3612",
+  "version": "1.1.3613",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",