@xuda.io/account_module 1.2.2309 → 1.2.2310

package/index.mjs

@@ -4247,6 +4247,7 @@ export const merge_contact = async function (req) {
   }
 
   const primary_contact_save_ret = await save_contact(uid, primary_contact_doc);
+  log_contact_activity(uid, contact_to_merge, 'merged_in', { count: contact_to_delete.length, emails: primary_contact_doc.email, note: 'kept as the primary of a duplicate set' });
 
   for (let contact_id of contact_to_delete) {
     try {
@@ -4255,6 +4256,7 @@ export const merge_contact = async function (req) {
       contact_doc.stat_ts = Date.now();
       contact_doc.stat_reason = 'merge';
       await save_contact(uid, contact_doc);
+      log_contact_activity(uid, contact_id, 'merged_away', { into: contact_to_merge, note: 'folded into the primary duplicate and closed' });
     } catch (error) {}
   }
 
@@ -4753,7 +4755,9 @@ export const update_contact = async function (req) {
       doc.profile_avatar = account_obj.account_info.profile_avatar;
     }
 
-    return await save_contact(uid, doc);
+    const save_ret = await save_contact(uid, doc);
+    log_contact_activity(uid, doc._id, 'updated', { stat, team_req_id, linked_account: contact_uid, note: contact_uid ? 'picture and avatar taken from the linked Xuda account' : undefined });
+    return save_ret;
   }
   return { code: -1, data: 'contact not found' };
 };
@@ -5663,6 +5667,16 @@ export const add_contact = async function (req, job_id, headers) {
 
     /////////////////
 
+    // Minted up front rather than at save time, so every classification step
+    // below can file its verdict under the contact it is deciding about. The
+    // steps run BEFORE the doc exists, which is exactly why their reasoning
+    // used to be unrecoverable.
+    const contact_id = await _common.xuda_get_uuid('contact');
+    const app_id = account_profile_info.app_id;
+    const activity = (event, detail) => log_contact_activity(uid, contact_id, event, detail, app_id);
+
+    await activity('created', { source: source || 'unknown', email: email.toLowerCase(), name: name || '', from_account: !!contact_uid, subject: metadata.subject, profile_id: account_profile_obj?._id });
+
     let is_spam = false;
     // let email_type_info;
     // let account_type_info;
@@ -5679,27 +5693,42 @@ export const add_contact = async function (req, job_id, headers) {
       }
 
       set_account_profile_picture(uid, contact_uid, metadata, job_id, headers, account_profile_info);
+      await activity('linked_account', { contact_uid });
     } else {
       is_spam = await isLikelySpamEmail(email);
+      if (is_spam) await activity('spam_check', { by: 'pattern', is_spam: true, note: 'address matched the local spam pattern list, no AI step ran' });
 
       // contact without use account
       cached_contact = await get_xuda_cache(uid, 'contact', email, 'metadata');
+      if (!_.isEmpty(cached_contact)) {
+        // Every classification below is SKIPPED on a cache hit, which is the single
+        // most confusing thing about the result: the contact inherits a verdict that
+        // was reached for an earlier contact on the same address or domain.
+        await activity('classification_reused', { from_cache: true, key: email.toLowerCase(), account_type: cached_contact.account_type, business_name: cached_contact?.business_info?.business_name, is_spam: cached_contact.is_spam });
+      }
 
       if (_.isEmpty(cached_contact)) {
         if (!is_spam && metadata.subject && !metadata.is_sent && !metadata.is_answered && !metadata.not_junk) {
           // deep search for spam
           is_spam = await ai_ms.is_spam_email(uid, email, metadata.subject, account_profile_info);
+          await activity('spam_check', { by: 'ai', is_spam: !!is_spam, subject: metadata.subject });
         }
         if (!is_spam) {
           const is_business = await ai_ms.is_business_contact(uid, email, name, metadata.subject, metadata.summarized_body, account_profile_info);
           account_type = is_business ? 'business' : 'personal';
+          await activity('classified', { by: 'ai', account_type, inputs: { email: email.toLowerCase(), name: name || '', subject: metadata.subject || '' } });
           if (is_business) {
             business_info = await ai_ms.get_business_info(uid, '', email, account_profile_info, { light: true });
             if (business_info.business_name !== 'Not available') {
+              await activity('business_info', { by: 'ai', depth: 'light', business_name: business_info.business_name, business_domain: business_info.business_domain, business_category: business_info.business_category });
               business_has_person = await ai_ms.is_business_contact_has_person(uid, email, name, metadata.subject, metadata.summarized_body, account_profile_info);
+              await activity('business_has_person', { by: 'ai', has_person: !!business_has_person });
             } else {
               account_type = 'personal';
               business_info = undefined;
+              // The reversal matters more than the original verdict: the card says
+              // personal even though the business call answered yes.
+              await activity('classified', { by: 'ai', account_type, reverted_from: 'business', reason: 'no business could be identified behind the address' });
             }
           }
           if (_.isEmpty(cached_contact) && account_type === 'business' && !business_has_person) {
@@ -5708,6 +5737,9 @@ export const add_contact = async function (req, job_id, headers) {
             } else {
               cached_contact = await get_xuda_cache(uid, 'contact', business_info.business_name, 'metadata');
             }
+            if (!_.isEmpty(cached_contact)) {
+              await activity('classification_reused', { from_cache: true, key: business_info.business_domain || business_info.business_name, account_type: cached_contact.account_type, business_name: cached_contact?.business_info?.business_name });
+            }
           }
         }
       }
@@ -5715,7 +5747,7 @@ export const add_contact = async function (req, job_id, headers) {
 
     const d = Date.now();
     const contact_obj = {
-      _id: await _common.xuda_get_uuid('contact'),
+      _id: contact_id,
       email: email.toLowerCase(),
       name: cached_contact?.name || name,
       stat: stat || 3,
@@ -5742,13 +5774,16 @@ export const add_contact = async function (req, job_id, headers) {
     if (!is_spam) {
       if (account_type === 'personal' || contact_obj?.business_has_person) {
         contact_obj.person_info = await ai_ms.get_person_info(uid, contact_obj.name, contact_obj.email, account_profile_info, metadata?.summarized_body, { light: true });
+        await activity('person_info', { by: 'ai', depth: 'light', full_name: contact_obj.person_info?.full_name, job_title: contact_obj.person_info?.job_title, company: contact_obj.person_info?.company_name });
         if (!contact_obj.name) {
           contact_obj.name = await ai_ms.get_name_from_email_addr(uid, contact_obj.email, account_profile_info);
+          await activity('name_resolved', { by: 'ai', from: 'email address', name: contact_obj.name });
         }
       }
 
       const conversation_obj = await ai_ms.create_openai_conversation();
       contact_obj.contact_reference_conversation_id = conversation_obj.id;
+      await activity('ai_thread_opened', { conversation_id: conversation_obj.id });
     } else {
       if (!contact_obj.name) {
         contact_obj.name = '';
@@ -5758,6 +5793,10 @@ export const add_contact = async function (req, job_id, headers) {
     const save_ret = await save_contact(uid, contact_obj);
     save_xuda_cache(uid, 'contact', contact_obj.email, null, contact_obj);
 
+    // The saved verdict, in one row, so the trail ends on the answer the card
+    // actually shows rather than making the reader replay the steps above.
+    await activity('saved', { account_type: contact_obj.account_type || 'unset', is_spam: !!contact_obj.is_spam, business_name: contact_obj?.business_info?.business_name, name: contact_obj.name || '' });
+
     if (!contact_obj.is_spam && contact_obj.name) {
       set_contact_profile_picture(uid, contact_obj._id, metadata, job_id, headers, account_profile_info, false);
     }
@@ -5821,6 +5860,7 @@ const set_contact_profile_picture = async function (uid, contact_id, metadata, j
         contact_obj.profile_picture_source = file_ret.profile_picture_source;
 
         const contact_save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, contact_obj);
+        log_contact_activity(uid, contact_id, 'picture_found', { by: cache ? 'cache' : 'ai', source: file_ret.profile_picture_source, account_type: contact_obj.account_type || 'unset' });
         // profile_picture = contact_obj.profile_picture;
       }
     }
@@ -5905,10 +5945,14 @@ const set_contact_profile_picture = async function (uid, contact_id, metadata, j
       contact_obj.profile_avatar = contact_obj?.profile_avatar_obj?.file_url;
       contact_obj.avatar_source = file_ret?.data?.avatar_source;
       const contact_save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, contact_obj);
+      log_contact_activity(uid, contact_id, 'avatar_ready', { by: cache ? 'cache' : 'ai', source: contact_obj.avatar_source, account_type: contact_obj.account_type || 'unset' });
     }
     await update_contact_profile_picture_status(uid, contact_id, 3);
   } catch (err) {
     await update_contact_profile_picture_status(uid, contact_id, 1, err.message);
+    // Worth a row of its own: a contact stuck on the shop / silhouette placeholder
+    // looks like a classification result, and this is the line that says otherwise.
+    log_contact_activity(uid, contact_id, 'picture_failed', { error: err?.message });
     delete_xuda_cache(contact_obj);
   }
 };
@@ -6141,6 +6185,7 @@ export const archive_contact = async function (req) {
     contact_doc.stat_reason = 'archived by the user';
 
     const contact_save_ret = await save_contact(uid, contact_doc);
+    log_contact_activity(uid, contact_id, 'archived', { by: 'user', reason: contact_doc.stat_reason });
 
     return contact_save_ret;
   } catch (err) {
@@ -6163,6 +6208,7 @@ export const delete_contact = async function (req, job_id, headers) {
     contact_doc.stat_reason = 'deleted by the user';
 
     const contact_save_ret = await save_contact(uid, contact_doc);
+    log_contact_activity(uid, contact_id, 'deleted', { by: 'user', reason: contact_doc.stat_reason, note: 'conversations attached to this contact were deleted with it' });
 
     ai_msa.delete_depended_chats(uid, contact_id);
     return contact_save_ret;
@@ -6188,6 +6234,7 @@ export const unarchive_contact = async function (req, job_id, headers) {
     contact_doc.stat_reason = 'unarchive by the user';
 
     const contact_save_ret = await save_contact(uid, contact_doc);
+    log_contact_activity(uid, contact_id, 'unarchived', { by: 'user', reason: contact_doc.stat_reason });
 
     if (!contact_doc.is_spam) {
       not_spam_contact(req, job_id, headers);
@@ -6217,6 +6264,7 @@ export const unfriend_contact = async function (req) {
 
     contact_doc.team_req_id = null;
     const contact_save_ret = await save_contact(uid, contact_doc);
+    log_contact_activity(uid, contact_id, 'unfriended', { by: 'user' });
 
     const req_save_ret = await db_module.save_couch_doc('xuda_team', req_doc);
 
@@ -6236,6 +6284,7 @@ export const pin_contact = async function (req) {
     contact_doc.pinned = true;
 
     const contact_save_ret = await save_contact(uid, contact_doc);
+    log_contact_activity(uid, contact_id, 'pinned', { by: 'user' });
 
     ws_dashboard_msa.emit_message_to_dashboard({
       service: 'contact_pinned',
@@ -6280,6 +6329,7 @@ export const unpin_contact = async function (req) {
     contact_doc.pinned = false;
 
     const contact_save_ret = await save_contact(uid, contact_doc);
+    log_contact_activity(uid, contact_id, 'unpinned', { by: 'user' });
 
     ws_dashboard_msa.emit_message_to_dashboard({
       service: 'contact_unpinned',
@@ -6311,22 +6361,30 @@ export const not_spam_contact = async function (req, job_id, headers) {
         stat: 3,
       });
     }
+    const was_spam = !!contact_doc.is_spam;
     contact_doc.is_spam = false;
+    log_contact_activity(uid, contact_id, 'marked_not_spam', { by: 'user', was_spam, note: was_spam ? 'address added to the spam whitelist, classification is being redone' : 'classification is being redone' });
 
     if (!contact_doc.contact_reference_conversation_id) {
       const conversation_obj = await ai_ms.create_openai_conversation();
       contact_doc.contact_reference_conversation_id = conversation_obj.id;
+      await log_contact_activity(uid, contact_id, 'ai_thread_opened', { conversation_id: conversation_obj.id });
     }
 
+    const previous_account_type = contact_doc.account_type;
     const is_business = await ai_ms.is_business_contact(uid, contact_doc.email, contact_doc.name, contact_doc?.metadata?.subject, contact_doc?.metadata?.summarized_body, account_profile_info);
     contact_doc.account_type = is_business ? 'business' : 'personal';
+    await log_contact_activity(uid, contact_id, 'classified', { by: 'ai', trigger: 'not spam', account_type: contact_doc.account_type, previous_account_type: previous_account_type || 'unset' });
     if (is_business) {
       contact_doc.business_info = await ai_ms.get_business_info(uid, '', contact_doc.email, account_profile_info, { light: true });
       if (contact_doc.business_info.business_name !== 'Not available') {
+        await log_contact_activity(uid, contact_id, 'business_info', { by: 'ai', depth: 'light', business_name: contact_doc.business_info.business_name, business_domain: contact_doc.business_info.business_domain, business_category: contact_doc.business_info.business_category });
         contact_doc.business_has_person = await ai_ms.is_business_contact_has_person(uid, contact_doc.email, contact_doc.name, contact_doc?.metadata?.subject, contact_doc?.metadata?.summarized_body, account_profile_info);
+        await log_contact_activity(uid, contact_id, 'business_has_person', { by: 'ai', has_person: !!contact_doc.business_has_person });
       } else {
         contact_doc.account_type = 'personal';
         contact_doc.business_info = undefined;
+        await log_contact_activity(uid, contact_id, 'classified', { by: 'ai', account_type: 'personal', reverted_from: 'business', reason: 'no business could be identified behind the address' });
       }
     }
 
@@ -6362,6 +6420,7 @@ export const not_spam_contact = async function (req, job_id, headers) {
       req.email_id = email._id;
       await email_ms.process_pending_email(req, job_id, headers);
     }
+    if (emails.docs.length) log_contact_activity(uid, contact_id, 'emails_reprocessed', { count: emails.docs.length, trigger: 'not spam', note: 'partially processed emails were re-read in full' });
 
     return contact_save_ret;
   } catch (err) {
@@ -6390,6 +6449,7 @@ export const generate_contact_avatar = async function (req, job_id, headers) {
 
     const contact_save_ret = await save_contact(uid, contact_doc);
     await delete_xuda_cache(contact_doc);
+    log_contact_activity(uid, contact_id, 'avatar_regenerate_requested', { by: 'user', note: 'existing picture and avatar cleared, a new avatar is being generated' });
     set_contact_profile_picture(uid, contact_doc._id, {}, job_id, headers, account_profile_info, true);
 
     return contact_save_ret;
@@ -6407,21 +6467,27 @@ export const set_deep_research_contact = async function (req, job_id, headers) {
   try {
     var contact_doc = await get_contact(uid, contact_id);
     contact_doc.deep_research = true;
+    await log_contact_activity(uid, contact_id, 'deep_research_started', { by: 'user', account_type: contact_doc.account_type || 'unset' });
 
     if (contact_doc.account_type === 'business') {
       contact_doc.business_info = await ai_ms.get_business_info(uid, '', contact_doc.email, account_profile_info);
       if (contact_doc.business_info.business_name !== 'Not available') {
+        await log_contact_activity(uid, contact_id, 'business_info', { by: 'ai', depth: 'deep', business_name: contact_doc.business_info.business_name, business_domain: contact_doc.business_info.business_domain, business_category: contact_doc.business_info.business_category });
         contact_doc.business_has_person = await ai_ms.is_business_contact_has_person(uid, contact_doc.email, contact_doc.name, contact_doc?.metadata?.subject, contact_doc?.metadata?.summarized_body, account_profile_info);
+        await log_contact_activity(uid, contact_id, 'business_has_person', { by: 'ai', has_person: !!contact_doc.business_has_person });
       } else {
         contact_doc.account_type = 'personal';
         contact_doc.business_info = undefined;
+        await log_contact_activity(uid, contact_id, 'classified', { by: 'ai', account_type: 'personal', reverted_from: 'business', reason: 'deep research found no business behind the address' });
       }
     }
 
     if (contact_doc.account_type === 'personal' || contact_doc?.business_has_person) {
       contact_doc.person_info = await ai_ms.get_person_info(uid, contact_doc.name, contact_doc.email, account_profile_info, contact_doc?.metadata?.summarized_body);
+      await log_contact_activity(uid, contact_id, 'person_info', { by: 'ai', depth: 'deep', full_name: contact_doc.person_info?.full_name, job_title: contact_doc.person_info?.job_title, company: contact_doc.person_info?.company_name });
       if (!contact_doc.name) {
         contact_doc.name = await ai_ms.get_name_from_email_addr(uid, contact_doc.email, account_profile_info);
+        await log_contact_activity(uid, contact_id, 'name_resolved', { by: 'ai', from: 'email address', name: contact_doc.name });
       }
     }
 
@@ -6456,6 +6522,8 @@ export const set_deep_research_contact = async function (req, job_id, headers) {
         throw err;
       }
     }
+    if (conversation_items.docs.length) log_contact_activity(uid, contact_id, 'attachments_transcribed', { count: conversation_items.docs.length, trigger: 'deep research' });
+    log_contact_activity(uid, contact_id, 'deep_research_finished', { account_type: contact_doc.account_type || 'unset', business_name: contact_doc?.business_info?.business_name });
 
     return contact_save_ret;
   } catch (err) {
@@ -6475,6 +6543,7 @@ export const unset_deep_research_contact = async function (req, job_id, headers)
 
     const contact_save_ret = await save_contact(uid, contact_doc);
     await delete_xuda_cache(contact_doc);
+    log_contact_activity(uid, contact_id, 'deep_research_turned_off', { by: 'user' });
 
     return contact_save_ret;
   } catch (err) {
@@ -6484,6 +6553,80 @@ export const unset_deep_research_contact = async function (req, job_id, headers)
     };
   }
 };
+
+// The trail for one contact, newest first.
+//
+// Recorded rows are only half the answer: every contact that existed before the
+// trail did has none, and those are most of them. So the contact doc is read back
+// into the same shape first (derived: true). The doc keeps one timestamp per
+// FIELD, not per step, so a derived row is stamped with the closest timestamp it
+// honestly has (date_created for the creation and the classification that ran
+// inside it, profile_avatar_stat_ts for the picture, stat_ts for the archive) and
+// says derived so the UI can mark it as reconstructed rather than observed.
+export const get_contact_activity = async function (req) {
+  const { uid, contact_id } = req;
+  try {
+    if (!contact_id) throw new Error('contact_id is missing');
+    const account_profile_info = await get_active_account_profile_info(uid);
+    const contact_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, contact_id);
+    if (!contact_doc || contact_doc.docType !== 'contact') throw new Error(`contact ${contact_id} not found`);
+    if (contact_doc.uid !== uid && contact_doc?.uid_created !== uid) throw new Error('Operation not allowed');
+
+    const recorded_ret = await db_module.find_app_couch_query(account_profile_info.app_id, {
+      selector: { docType: 'contact_activity', contact_id },
+      limit: 500,
+    });
+    const recorded = (recorded_ret?.docs || []).map((d) => ({ event: d.event, detail: d.detail || {}, ts: d.ts, derived: false }));
+
+    const derived = [];
+    const add = (event, ts, detail) => {
+      if (!ts) return;
+      // A recorded row always wins: it has the real timestamp and the real inputs.
+      if (recorded.some((r) => r.event === event)) return;
+      derived.push({ event, detail, ts, derived: true });
+    };
+
+    const created_ts = contact_doc.date_created || contact_doc.ts;
+    add('created', created_ts, { source: contact_doc.source || 'unknown', email: contact_doc.email, name: contact_doc.name || '', from_account: !!contact_doc.contact_uid, subject: contact_doc?.metadata?.subject });
+    if (contact_doc.is_spam) add('spam_check', created_ts, { is_spam: true });
+    if (contact_doc.account_type) add('classified', created_ts, { account_type: contact_doc.account_type });
+    if (contact_doc?.business_info?.business_name) add('business_info', created_ts, { business_name: contact_doc.business_info.business_name, business_domain: contact_doc.business_info.business_domain, business_category: contact_doc.business_info.business_category });
+    if (contact_doc.business_has_person !== undefined && contact_doc.business_has_person !== null) add('business_has_person', created_ts, { has_person: !!contact_doc.business_has_person });
+    if (contact_doc?.person_info) add('person_info', created_ts, { full_name: contact_doc.person_info.full_name || contact_doc.person_info.person_full_name, job_title: contact_doc.person_info.job_title, company: contact_doc.person_info.company_name });
+    if (contact_doc.contact_reference_conversation_id) add('ai_thread_opened', created_ts, { conversation_id: contact_doc.contact_reference_conversation_id });
+    if (contact_doc.profile_picture) add('picture_found', contact_doc.profile_avatar_stat_ts || created_ts, { source: contact_doc.profile_picture_source });
+    if (contact_doc.profile_avatar) add('avatar_ready', contact_doc.profile_avatar_stat_ts || created_ts, { source: contact_doc.avatar_source });
+    if (contact_doc.profile_avatar_stat === 1 && contact_doc.profile_avatar_error) add('picture_failed', contact_doc.profile_avatar_stat_ts, { error: contact_doc.profile_avatar_error });
+    if (contact_doc.deep_research) add('deep_research_started', contact_doc.stat_ts || created_ts, {});
+    if (contact_doc.pinned) add('pinned', contact_doc.stat_ts || created_ts, {});
+    // stat carries only the LAST transition, which is why an archive/unarchive
+    // history is exactly what the recorded trail adds from here on.
+    if (contact_doc.stat === 5) add('archived', contact_doc.stat_ts, { reason: contact_doc.stat_reason });
+    if (contact_doc.stat === 4) add('deleted', contact_doc.stat_ts, { reason: contact_doc.stat_reason });
+
+    const rows = [...recorded, ...derived].sort((a, b) => (b.ts || 0) - (a.ts || 0));
+
+    return {
+      code: 1,
+      data: {
+        contact_id,
+        // What the card shows today, so the UI can head the trail with the outcome.
+        current: {
+          account_type: contact_doc.account_type || null,
+          is_spam: !!contact_doc.is_spam,
+          stat: contact_doc.stat,
+          source: contact_doc.source || null,
+          deep_research: !!contact_doc.deep_research,
+          business_name: contact_doc?.business_info?.business_name || null,
+          profile_avatar_stat: contact_doc.profile_avatar_stat,
+        },
+        rows,
+      },
+    };
+  } catch (err) {
+    return { code: -25, data: err.message };
+  }
+};
 //////// PROFILES  //////////////
 
 export const get_pending_share_profile_in = async function (uid, _id) {
@@ -7030,6 +7173,48 @@ export const get_contact = async function (uid, contact_id) {
   return contact_ret;
 };
 
+// ---------------------------------------------------------------------------
+// Contact activity trail
+//
+// A contact accumulates a lot of history that was previously only visible as
+// the END STATE on its own doc: it was created from somewhere, several AI steps
+// ran on it and each decided something (spam, business or personal, the business
+// profile, the person profile, the name, the avatar), and it may since have been
+// archived, unarchived, pinned, re-classified or sent to deep research. The doc
+// keeps the last answer of each and nothing about when, in what order, or what
+// the previous answer was, so "why is this contact a business" had no trace to
+// read back.
+//
+// One `contact_activity` doc per event, in the same app db as the contact.
+// Deliberately append-only and deliberately silent: a failure to WRITE the trail
+// must never fail the action being recorded, so every call is wrapped and logged
+// to the console instead of thrown. Callers do not await it for that reason
+// either, except where the next line already awaits something else anyway.
+// ---------------------------------------------------------------------------
+const log_contact_activity = async function (uid, contact_id, event, detail = {}, app_id) {
+  try {
+    if (!uid || !contact_id || !event) return null;
+    const app = app_id || (await get_active_account_profile_info(uid))?.app_id;
+    if (!app) return null;
+
+    return await db_module.save_app_couch_doc_native(app, {
+      _id: await _common.xuda_get_uuid('contact_activity'),
+      docType: 'contact_activity',
+      contact_id,
+      uid,
+      event,
+      // Values the UI prints back verbatim, so keep them short and human. Never
+      // put a full AI response or an email body here: the trail is a summary.
+      detail,
+      ts: Date.now(),
+      stat: 3,
+    });
+  } catch (err) {
+    console.error('[account_module] contact activity not recorded:', event, contact_id, err?.message);
+    return null;
+  }
+};
+
 export const save_contact = async function (uid, contact_doc) {
   const account_profile_info = await get_active_account_profile_info(uid);
   const contact_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, contact_doc);

package/index_ms.mjs

@@ -449,6 +449,10 @@ export const unset_deep_research_contact = async function (...args) {
   return await broker.send_to_queue("unset_deep_research_contact", ...args);
 };
 
+export const get_contact_activity = async function (...args) {
+  return await broker.send_to_queue("get_contact_activity", ...args);
+};
+
 export const get_pending_share_profile_in = async function (...args) {
   return await broker.send_to_queue("get_pending_share_profile_in", ...args);
 };

package/index_msa.mjs

@@ -449,6 +449,10 @@ export const unset_deep_research_contact =  function (...args) {
    broker.send_to_queue_async("unset_deep_research_contact", ...args);
 };
 
+export const get_contact_activity =  function (...args) {
+   broker.send_to_queue_async("get_contact_activity", ...args);
+};
+
 export const get_pending_share_profile_in =  function (...args) {
    broker.send_to_queue_async("get_pending_share_profile_in", ...args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/account_module",
-  "version": "1.2.2309",
+  "version": "1.2.2310",
   "description": "Xuda Account Server Module",
   "main": "index.mjs",
   "dependencies": {