@xuda.io/ai_module 1.1.5646 → 1.1.5647

package/index.mjs

@@ -11285,6 +11285,90 @@ async function normalizeBase64To1024(
   return normalizedBuffer.toString('base64');
 }
 
+// Upload-time content check for a profile picture or a business logo.
+//
+// Deliberately NOT identity verification. It answers "is this the right KIND of
+// image, and is it good enough to use", never "is this the right person". There
+// is no face embedding, no matching against a reference, and nothing about the
+// image is retained — so this does not cross the biometric line drawn in
+// docs/plans/xuda-verify-consent.md, which stays gated on the face-model
+// decision and that document's pre-capture prerequisites. Identity matching is
+// still the unbuilt half of phase 2, see
+// docs/plans/handoff_profile_image_verification.md.
+//
+// The same classification already existed as a private closure inside
+// get_profile_avatar (inspect_person_in_image), but it only ran at AVATAR
+// GENERATION time, which is after verification. Users need the answer while
+// they are still looking at the picker, so it lives here as its own method and
+// covers the business/logo case the original never did.
+export const inspect_profile_picture = async function (req, job_id, headers) {
+  try {
+    const data = req?.data || req || {};
+    const uid = req?.uid;
+    const url = data.url;
+    const account_type = data.account_type === 'business' ? 'business' : 'personal';
+
+    if (!uid) return { code: -401, data: 'not authorized' };
+    if (!url) return { code: -1, data: 'url is required' };
+
+    // Attribution only; a missing profile must not block the check.
+    let account_profile_info;
+    try {
+      account_profile_info = await account_ms.get_active_account_profile_info(uid);
+    } catch (e) {}
+
+    const image_blob_ret = await get_image_blob_from_downloaded_image(url);
+    if (!image_blob_ret?.image_blob) return { code: -1, data: 'could not read that image' };
+    const base64 = Buffer.from(await image_blob_ret.image_blob.arrayBuffer()).toString('base64');
+
+    const is_business = account_type === 'business';
+    const instruction = is_business
+      ? `This image was uploaded as the COMPANY LOGO for a business account. Decide whether it is usable as that logo or brand mark. Reject a photograph of a person, a selfie, a stock photo, a screenshot, a meme, an unrelated object, or an image with no identifiable mark. Also reject it if it is too blurry, too small or too cropped to use.`
+      : `This image was uploaded as a PERSONAL PROFILE PICTURE. Decide whether it is a genuine photograph of a real person, suitable as an authentic account portrait. Reject a company logo, an illustration, a cartoon, an obviously AI-generated render, an object, an animal, a screenshot, or a group shot with no single clear subject. Also reject it if the face is not visible, heavily cropped, very blurry, or too small.`;
+
+    const ret = await submit_chat_gpt_prompt({
+      uid,
+      model: _conf.default_ai_model,
+      prompt: [
+        {
+          role: 'user',
+          content: [
+            { type: 'input_text', text: `${instruction}\n\nBe practical rather than strict: an ordinary phone photo in ordinary lighting is fine. Only reject when a real person would agree it is the wrong kind of image or genuinely unusable.` },
+            { type: 'input_image', image_url: `data:image/png;base64,${base64}` },
+          ],
+        },
+      ],
+      response_format: z.object({
+        acceptable: z.boolean().describe('true only if the image is the right kind AND usable quality'),
+        reason_code: z
+          .string()
+          .describe(
+            'snake_case code. Use ok when acceptable. Otherwise one of: not_a_person, is_a_logo, illustration, ai_generated, object_or_animal, screenshot, multiple_faces, face_not_visible, too_blurry, too_small, too_cropped, not_a_logo, no_clear_mark',
+          ),
+        message: z.string().describe('one short, friendly sentence telling the user what to upload instead. No jargon, no mention of models or scores.'),
+      }),
+      metadata: { func: 'inspect_profile_picture', account_type },
+      account_profile_info,
+    });
+
+    if (ret.code < 0) return ret;
+
+    const res = JSON5.parse(ret.data);
+    return {
+      code: 1,
+      data: {
+        acceptable: Boolean(res?.acceptable),
+        reason_code: res?.reason_code || (res?.acceptable ? 'ok' : 'unusable'),
+        message: res?.message || '',
+        account_type,
+      },
+    };
+  } catch (err) {
+    console.error('[inspect_profile_picture]', err.message);
+    return { code: -1, data: err.message };
+  }
+};
+
 const get_image_blob_from_downloaded_image = async function (url) {
   async function hasTransparentBackground(filePath) {
     const image = sharp(filePath);

package/index_ms.mjs

@@ -241,6 +241,10 @@ export const is_business_contact_has_person = async function (...args) {
   return await broker.send_to_queue("is_business_contact_has_person", ...args);
 };
 
+export const inspect_profile_picture = async function (...args) {
+  return await broker.send_to_queue("inspect_profile_picture", ...args);
+};
+
 export const get_name_from_email_addr = async function (...args) {
   return await broker.send_to_queue("get_name_from_email_addr", ...args);
 };

package/index_msa.mjs

@@ -241,6 +241,10 @@ export const is_business_contact_has_person =  function (...args) {
    broker.send_to_queue_async("is_business_contact_has_person", ...args);
 };
 
+export const inspect_profile_picture =  function (...args) {
+   broker.send_to_queue_async("inspect_profile_picture", ...args);
+};
+
 export const get_name_from_email_addr =  function (...args) {
    broker.send_to_queue_async("get_name_from_email_addr", ...args);
 };

package/package.json

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