@xuda.io/ai_module 1.1.5615 → 1.1.5616

package/index.mjs

@@ -2076,7 +2076,7 @@ export const unarchive_ai_chat = async function (req) {
 //   }
 // };
 
-const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', size = '1024x1024', n = 1, width = 256, height = 256, metadata = {}, account_profile_info) {
+const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', size = '1024x1024', n = 1, width = 256, height = 256, metadata = {}, account_profile_info, quality) {
   try {
     let response;
     try {
@@ -2085,10 +2085,11 @@ const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', si
         prompt,
         size,
         n,
-        // Output is downscaled to width×height (default 256²) right below, so a
-        // high-quality 1024² render is wasted. 'low' is indistinguishable at
-        // thumbnail size and 2-8x cheaper. Tunable via _conf.chat_image_quality.
-        quality: _conf.chat_image_quality || 'low',
+        // Chat-image output is downscaled to width×height (default 256²) right
+        // below, so a high-quality 1024² render is wasted there → default 'low'.
+        // Callers that need a real avatar (e.g. the factual avatar) pass an explicit
+        // `quality` ('medium'). Tunable via _conf.chat_image_quality for the default.
+        quality: quality || _conf.chat_image_quality || 'low',
       });
       report_ai_status(model);
     } catch (err) {
@@ -8338,7 +8339,9 @@ export const get_profile_picture = async function (uid, account_type = 'business
       }
 
       if (factual_image_mode) {
-        imageBase64 = await create_image(uid, factual_prompt, undefined, undefined, 1, undefined, undefined, {}, account_profile_info);
+        // Factual avatar is a real user-facing profile image, not a chat thumbnail —
+        // generate at medium (overridable via _conf.factual_avatar_quality), not the low default.
+        imageBase64 = await create_image(uid, factual_prompt, undefined, undefined, 1, undefined, undefined, {}, account_profile_info, _conf.factual_avatar_quality || 'medium');
       } else {
         const model = 'gpt-image-1-mini'; // 'chatgpt-image-latest';
         const prompt = `
@@ -14135,7 +14138,7 @@ const _widget_verify_google_id_token = async function (id_token) {
   return payload;
 };
 
-const _widget_find_or_create_visitor = async function (email, name, google_sub) {
+const _widget_find_or_create_visitor = async function (email, name, google_sub, picture) {
   const ret = await db_module.find_couch_query('xuda_accounts', {
     selector: { 'account_info.email': email },
     fields: ['_id'],
@@ -14143,14 +14146,26 @@ const _widget_find_or_create_visitor = async function (email, name, google_sub)
   });
   if (ret.docs && ret.docs.length) {
     // If we have a google_sub and the existing account lacks one, attach it.
-    if (google_sub) {
+    // Also seed the Google photo as the profile_picture when the account has no
+    // avatar yet, so avatar generation has a source to work from.
+    if (google_sub || picture) {
       try {
         const acct_ret = await db_module.get_couch_doc('xuda_accounts', ret.docs[0]._id);
         if (acct_ret.code > -1) {
           const acct = acct_ret.data;
-          if (!acct.google_sub) {
+          let dirty = false;
+          if (google_sub && !acct.google_sub) {
             acct.google_sub = google_sub;
             acct.google_linked = true;
+            dirty = true;
+          }
+          acct.account_info = acct.account_info || {};
+          if (picture && !acct.account_info.profile_picture && !acct.account_info.profile_avatar) {
+            acct.account_info.profile_picture = picture;
+            acct.account_info.profile_picture_source = 'google';
+            dirty = true;
+          }
+          if (dirty) {
             acct.ts = Date.now();
             await db_module.save_couch_doc('xuda_accounts', acct);
           }
@@ -14164,6 +14179,13 @@ const _widget_find_or_create_visitor = async function (email, name, google_sub)
   const secret = _utils.get_id('tmp_pass', 5);
   const hash = _utils.hash(secret);
   const { first_name, last_name } = _widget_split_name(name);
+  const account_info = { email, username: _utils.get_id('xu'), first_name, last_name, full_name: name };
+  // Seed the Google profile photo so the avatar-generation step has a source.
+  if (picture) {
+    account_info.profile_picture = picture;
+    account_info.profile_picture_source = 'google';
+    account_info.profile_avatar_stat = 0;
+  }
   const doc = {
     _id: await _common.xuda_get_uuid('account'),
     stat: 1,
@@ -14171,7 +14193,7 @@ const _widget_find_or_create_visitor = async function (email, name, google_sub)
     source: 'widget',
     password: hash,
     email,
-    account_info: { email, username: _utils.get_id('xu'), first_name, last_name, full_name: name },
+    account_info,
   };
   if (google_sub) {
     doc.google_sub = google_sub;
@@ -14332,7 +14354,7 @@ export const get_widget_embed_snippet = async function (req, job_id, headers) {
 };
 
 const _widget_signup_core = async function (req, job_id, headers, opts) {
-  const { profile_id, email, name, widget_origin, google_sub, signup_method, visitor_lang } = req;
+  const { profile_id, email, name, widget_origin, google_sub, picture, signup_method, visitor_lang } = req;
   const [owner_uid_part, pid_part] = String(profile_id || '').split('.');
   if (!owner_uid_part || !pid_part) return { code: -404, data: 'invalid_profile' };
 
@@ -14343,8 +14365,17 @@ const _widget_signup_core = async function (req, job_id, headers, opts) {
   const ap_doc = account_profile_info.account_profile_obj || {};
   if (ap_doc.widget_enabled === false) return { code: -404, data: 'widget_disabled' };
 
-  const visitor_uid = await _widget_find_or_create_visitor(email, name, google_sub);
-  return await _widget_signup_finalize(visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang);
+  const visitor_uid = await _widget_find_or_create_visitor(email, name, google_sub, picture);
+
+  // Kick off persona-avatar generation for the visitor from their Google photo.
+  // Fire-and-forget in the account_module worker; the client polls widget_get_avatar.
+  if (picture) {
+    try {
+      account_msa.ensure_profile_avatar({ uid: visitor_uid }, job_id, headers);
+    } catch (err) {}
+  }
+
+  return await _widget_signup_finalize(visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang, picture);
 };
 
 export const widget_signup = async function (req, job_id, headers) {
@@ -14379,14 +14410,177 @@ export const widget_signup_google = async function (req, job_id, headers) {
       .trim();
     const name = String(payload.name || payload.email?.split('@')[0] || 'Friend').trim();
     if (!email) return { code: -1, data: 'no_email_in_token' };
+    const picture = typeof payload.picture === 'string' ? payload.picture : '';
+
+    return await _widget_signup_core({ profile_id, email, name, widget_origin, visitor_lang, google_sub: payload.sub, picture, signup_method: 'google' }, job_id, headers);
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+// Site-level Google sign-in (e.g. the xuda.network topbar). Unlike
+// widget_signup_google this is NOT tied to a persona/chat — it performs the
+// same "complete setup of the user in xuda" the widget does (verify the Google
+// token, then find-or-create + link the visitor's free xuda account by
+// google_sub, and kick off avatar generation from their Google photo), so a
+// visitor is fully provisioned at site login, before they ever open a chat.
+// The chat widget later just links the already-provisioned account to a persona.
+export const site_signup_google = async function (req, job_id, headers) {
+  try {
+    const { id_token } = req;
+    if (!id_token || typeof id_token !== 'string') return { code: -1, data: 'missing_id_token' };
+
+    let payload;
+    try {
+      payload = await _widget_verify_google_id_token(id_token);
+    } catch (err) {
+      return { code: -401, data: err.message || 'google_token_invalid' };
+    }
+
+    const email = String(payload.email || '')
+      .toLowerCase()
+      .trim();
+    const name = String(payload.name || payload.email?.split('@')[0] || 'Friend').trim();
+    if (!email) return { code: -1, data: 'no_email_in_token' };
+    const picture = typeof payload.picture === 'string' ? payload.picture : '';
+
+    const visitor_uid = await _widget_find_or_create_visitor(email, name, payload.sub, picture);
 
-    return await _widget_signup_core({ profile_id, email, name, widget_origin, visitor_lang, google_sub: payload.sub, signup_method: 'google' }, job_id, headers);
+    // Fire-and-forget avatar generation from the Google photo, same as the widget.
+    if (picture) {
+      try {
+        account_msa.ensure_profile_avatar({ uid: visitor_uid }, job_id, headers);
+      } catch (err) {}
+    }
+
+    const { first_name, last_name } = _widget_split_name(name);
+    return {
+      code: 1,
+      data: {
+        uid: visitor_uid,
+        email,
+        name,
+        first_name,
+        last_name,
+        picture,
+        account_active: true,
+        signin_url: `https://${_conf.domain || 'xuda.ai'}/dashboard/login`,
+      },
+    };
   } catch (err) {
     return { code: -1, data: err.message || String(err) };
   }
 };
 
-const _widget_signup_finalize = async function (visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang) {
+// Public-profile "Ask Friendship". A visitor on /public_profiles/<target_uid>
+// signs in with Google (same find-or-create as site_signup_google), then we send
+// a contact_connection team_request to the profile owner. Auto-accepts (canonical
+// bidirectional contacts) when the owner has auto_respond enabled; otherwise the
+// owner gets an invitation email and the request stays pending. Never direct
+// add_contact — always the team_request invitation flow.
+export const public_profile_ask_friendship = async function (req, job_id, headers) {
+  try {
+    const { id_token, target_uid } = req;
+    if (!id_token || typeof id_token !== 'string') return { code: -1, data: 'missing_id_token' };
+    if (!target_uid || typeof target_uid !== 'string') return { code: -1, data: 'missing_target_uid' };
+
+    let payload;
+    try {
+      payload = await _widget_verify_google_id_token(id_token);
+    } catch (err) {
+      return { code: -401, data: err.message || 'google_token_invalid' };
+    }
+    const email = String(payload.email || '')
+      .toLowerCase()
+      .trim();
+    const name = String(payload.name || payload.email?.split('@')[0] || 'Friend').trim();
+    if (!email) return { code: -1, data: 'no_email_in_token' };
+    const picture = typeof payload.picture === 'string' ? payload.picture : '';
+
+    // Target must be an active, non-opted-out account.
+    const target_ret = await account_ms.get_account_name({ uid_query: target_uid });
+    if (!target_ret || target_ret.code < 0) return { code: -404, data: 'target_not_found' };
+    const target = target_ret.data || {};
+    if (target.stat !== 3 || target.public_profile_disabled === true) return { code: -404, data: 'target_unavailable' };
+    const target_name = [target.first_name, target.last_name].filter(Boolean).join(' ') || target.username || 'Xuda Member';
+
+    // Find or create the visitor's xuda account (same setup as site_signup_google).
+    const visitor_uid = await _widget_find_or_create_visitor(email, name, payload.sub, picture);
+    if (visitor_uid === target_uid) return { code: -1, data: 'cannot_friend_self' };
+    if (picture) {
+      try {
+        account_msa.ensure_profile_avatar({ uid: visitor_uid }, job_id, headers);
+      } catch (err) {}
+    }
+
+    const { first_name, last_name } = _widget_split_name(name);
+    const visitor_first_name = first_name || '';
+
+    // Dedupe: reuse an existing request from this visitor to this target.
+    const existing_ret = await db_module.find_couch_query('xuda_team', {
+      selector: {
+        docType: 'team_request',
+        access_type: 'contact_connection',
+        team_req_from_uid: visitor_uid,
+        team_req_to_uid: target_uid,
+        contact_source: 'public_profile',
+      },
+      limit: 1,
+    });
+    let team_req_doc = existing_ret?.docs?.[0] || null;
+
+    if (!team_req_doc) {
+      const team_req_id = await _common.xuda_get_uuid('team_req');
+      team_req_doc = {
+        _id: team_req_id,
+        team_req_id,
+        team_req_date: Date.now(),
+        team_req_status_date: null,
+        team_req_to_email: target.email || '',
+        team_req_to_uid: target_uid,
+        team_req_stat: 2,
+        team_req_stat_desc: 'public profile friend request',
+        team_req_from_uid: visitor_uid,
+        docType: 'team_request',
+        team_req_app_id: null,
+        access_type: 'contact_connection',
+        uid: visitor_uid,
+        contact_source: 'public_profile',
+        share_item_id: target_uid,
+        sender_account_info: { email, first_name, last_name, full_name: name },
+      };
+      const tr_save = await db_module.save_couch_doc('xuda_team', team_req_doc);
+      if (tr_save.code < 0) return { code: -1, data: tr_save.data || 'team_request_create_failed' };
+
+      // fire-and-forget — the invitation email shouldn't block the response
+      team_ms.send_access_invitation({ team_req_id: team_req_doc._id }).catch(() => {});
+    }
+
+    let state = team_req_doc.team_req_stat === 3 ? 'open' : team_req_doc.team_req_stat === 4 ? 'declined' : 'pending';
+
+    // Auto-accept when the owner's active profile has auto_respond — performs the
+    // canonical bidirectional contact creation via confirm_team_request.
+    if (state === 'pending') {
+      let auto_accept = false;
+      try {
+        const tgt_ap = await get_active_account_profile_info(target_uid);
+        auto_accept = !!tgt_ap?.account_profile_obj?.auto_respond;
+      } catch (err) {}
+      if (auto_accept) {
+        try {
+          const cret = await team_ms.confirm_team_request({ team_req_id: team_req_doc._id });
+          if (cret && cret.code > -1) state = 'open';
+        } catch (err) {}
+      }
+    }
+
+    return { code: 1, data: { state, visitor_first_name, target_name } };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+const _widget_signup_finalize = async function (visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang, picture) {
   try {
     let team_req_doc = await _widget_find_existing_team_req(visitor_uid, canonical_profile_id);
     let assigned_uid;
@@ -14498,6 +14692,9 @@ const _widget_signup_finalize = async function (visitor_uid, email, name, widget
         greeting,
         conversation_id,
         visitor_first_name,
+        visitor_uid,
+        // 1 = avatar generation kicked off (poll widget_get_avatar); 0 = none in flight
+        avatar_stat: picture ? 1 : 0,
         signup_method: signup_method || 'email',
         account_active: signup_method === 'google',
         signin_url: signup_method === 'google' ? `https://${_conf.domain || 'xuda.ai'}/dashboard/login` : undefined,
@@ -14508,6 +14705,59 @@ const _widget_signup_finalize = async function (visitor_uid, email, name, widget
   }
 };
 
+// Build the avatar-poll payload for an account: generation status plus the
+// avatar as base64 so an embedding page can draw it to a <canvas> without a
+// cross-origin taint (drive URLs may not send CORS headers).
+const _account_avatar_payload = async function (uid) {
+  const acct_ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  if (acct_ret.code < 0 || !acct_ret.data) return null;
+  const info = acct_ret.data.account_info || {};
+  let avatar_b64 = null;
+  if (info.profile_avatar) {
+    try {
+      const blob_ret = await get_image_blob_from_downloaded_image(info.profile_avatar);
+      avatar_b64 = Buffer.from(await blob_ret.image_blob.arrayBuffer()).toString('base64');
+    } catch (err) {}
+  }
+  return {
+    // 0 none · 1 started · 2 generating · 3 done (profile_avatar set)
+    profile_avatar_stat: info.profile_avatar_stat || 0,
+    profile_avatar: info.profile_avatar || null,
+    profile_avatar_error: info.profile_avatar_error || null,
+    avatar_b64,
+  };
+};
+
+// Poll the visitor's generated persona avatar after a widget Google signup.
+// Auth is the widget_token (the session resolves the visitor uid).
+export const widget_get_avatar = async function (req) {
+  try {
+    const { widget_token } = req || {};
+    const session = await _widget_load_session(widget_token);
+    if (!session) return { code: -401, data: 'invalid_session' };
+    const payload = await _account_avatar_payload(session.visitor_uid);
+    if (!payload) return { code: -1, data: 'visitor_not_found' };
+    return { code: 1, data: payload };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+// Poll the generated avatar after a site_signup_google (no widget session). The
+// uid is the long random account id returned by site_signup_google — not
+// enumerable — and only non-sensitive avatar fields are returned.
+export const site_get_avatar = async function (req) {
+  try {
+    const { uid } = req || {};
+    if (!uid || typeof uid !== 'string') return { code: -1, data: 'missing_uid' };
+    const payload = await _account_avatar_payload(uid);
+    if (!payload) return { code: -1, data: 'account_not_found' };
+    return { code: 1, data: payload };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
 export const widget_send_message = async function (req, job_id, headers) {
   try {
     const { widget_token, prompt = '', attachments = [] } = req;

package/index_ms.mjs

@@ -281,6 +281,22 @@ export const widget_signup_google = async function (...args) {
   return await broker.send_to_queue("widget_signup_google", ...args);
 };
 
+export const site_signup_google = async function (...args) {
+  return await broker.send_to_queue("site_signup_google", ...args);
+};
+
+export const public_profile_ask_friendship = async function (...args) {
+  return await broker.send_to_queue("public_profile_ask_friendship", ...args);
+};
+
+export const widget_get_avatar = async function (...args) {
+  return await broker.send_to_queue("widget_get_avatar", ...args);
+};
+
+export const site_get_avatar = async function (...args) {
+  return await broker.send_to_queue("site_get_avatar", ...args);
+};
+
 export const widget_send_message = async function (...args) {
   return await broker.send_to_queue("widget_send_message", ...args);
 };

package/index_msa.mjs

@@ -281,6 +281,22 @@ export const widget_signup_google =  function (...args) {
    broker.send_to_queue_async("widget_signup_google", ...args);
 };
 
+export const site_signup_google =  function (...args) {
+   broker.send_to_queue_async("site_signup_google", ...args);
+};
+
+export const public_profile_ask_friendship =  function (...args) {
+   broker.send_to_queue_async("public_profile_ask_friendship", ...args);
+};
+
+export const widget_get_avatar =  function (...args) {
+   broker.send_to_queue_async("widget_get_avatar", ...args);
+};
+
+export const site_get_avatar =  function (...args) {
+   broker.send_to_queue_async("site_get_avatar", ...args);
+};
+
 export const widget_send_message =  function (...args) {
    broker.send_to_queue_async("widget_send_message", ...args);
 };

package/package.json

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