@xuda.io/account_module 1.2.2310 → 1.2.2312

package/index.mjs

@@ -3535,6 +3535,7 @@ export const get_account_name = async function (req) {
       active_account_profile_id,
       network_country_code,
       public_profile_disabled,
+      verify_level,
     } = data.data.account_info;
 
     obj = {
@@ -3570,6 +3571,11 @@ export const get_account_name = async function (req) {
       // email,// email?.[0] || '',
       avatar_source,
       active_account_profile_id,
+      // The verification level of the account behind a card. Every caller that
+      // builds a contact card off another account copies this onto the card doc
+      // so the background tile can say what the level is; without it a card for
+      // a verified person read as L0, which is a false statement about them.
+      verify_level,
     };
   }
   return { code: 1, data: obj }; //is_online: data?.data?.socket_id ? true : false
@@ -4305,6 +4311,13 @@ const level_pattern = function (doc) {
   return `level-${level}-pattern.png`;
 };
 
+// The level tile is the DEFAULT for every contact card, not a fallback. It used
+// to be computed first and then overwritten by a tile keyed off where the
+// contact came from (xu / authentic / fictional / email / web), so a card for a
+// verified person showed the generic XU tile and the level never appeared on any
+// card that had a contact_uid, which is every card for a real account. Only the
+// states that say the card cannot show a level at all still win: a shared card
+// wears its owner's avatar, an avatar being processed says so, and spam says so.
 const get_contact_pattern = async function (doc) {
   let ret = level_pattern(doc);
 
@@ -4325,84 +4338,12 @@ const get_contact_pattern = async function (doc) {
     }
   } else if (doc.is_spam) {
     ret = `spam-pattern.png`;
-  } else {
-    // if (doc.account_type === 'business') {
-    //   // if (doc?.is_real_person) {
-    //   ret = doc.profile_picture;
-    //   // }
-    // } else {
-    // if (doc.my_contact) {
-    //   if (doc.account_type === 'business') {
-    //     ret = doc.profile_picture;
-    //   } else {
-    //     switch (doc.avatar_source) {
-    //       case 'fictional':
-    //         ret = `fictional-avatar-pattern.png`;
-    //         break;
-
-    //       case 'ai profile':
-    //         ret = `fictional-avatar-pattern.png`;
-    //         break;
-
-    //       case 'authentic profile':
-    //         ret = `authentic-avatar-pattern.png`;
-    //         break;
-
-    //       default:
-    //         ret = `xu-pattern.png`;
-    //         break;
-    //     }
-    //   }
-    // } else
-
-    // if (doc?.shared_from_uid) {
-    //   //&& (doc.pending || (doc.team_req_id && doc.contact_share_copy))) {
-    //   // pending or active share request
-    //   const shared_from_uid_ret = await get_account_name({ uid_query: doc.shared_from_uid });
-    //   ret = shared_from_uid_ret.data.profile_avatar;
-    // }
-
-    // else if (doc?.reference_doc?.shared_from_uid) {
-    //   //active share
-    //   const shared_from_uid_ret = await get_account_name({ uid_query: doc.reference_doc.shared_from_uid });
-    //   ret = shared_from_uid_ret.data.profile_avatar;
-    // }
-    // else
-    if (doc.contact_uid) {
-      switch (doc.avatar_source) {
-        case 'fictional':
-          ret = `fictional-avatar-pattern.png`;
-          break;
-
-        case 'ai profile':
-          ret = `fictional-avatar-pattern.png`;
-          break;
-
-        case 'authentic profile':
-          ret = `authentic-avatar-pattern.png`;
-          break;
-
-        default:
-          ret = `xu-pattern.png`;
-          break;
-      }
-    } else {
-      switch (doc.source) {
-        case 'read emails': {
-          ret = `email-pattern.png`;
-          break;
-        }
-        case 'web': {
-          ret = `web-pattern.png`;
-          break;
-        }
-
-        default:
-          break;
-      }
-    }
-    // }
   }
+  // Everything else keeps the level tile. The old where-it-came-from tiles
+  // (xu / authentic / fictional for an account, email / web for a scraped
+  // contact) are gone on purpose: they occupied the one surface that now
+  // carries the verification level, and a contact with no account behind it
+  // has no level to show, which is exactly what L0 says.
   return ret;
 };
 
@@ -4570,6 +4511,10 @@ export const get_contact_info = async function (uid, contact_doc, _id) {
       }
 
       doc.avatar_source = account_info_ret.data.avatar_source;
+      // The card's background tile is the contact's verification level, and the
+      // level lives on the account, not on my copy of them. Carry it over here,
+      // where the account is already in hand, so the tile costs no extra read.
+      doc.verify_level = account_info_ret.data.verify_level;
       // doc.icon_pattern = await get_contact_pattern(doc);
       doc.username = account_info_ret.data.username;
       doc.business_name = account_info_ret.data.business_name;
@@ -4634,6 +4579,7 @@ export const get_pending_contact_out = async function (uid, _id) {
       doc.account_type = account_info_ret.data.account_type;
       doc.avatar_source = account_info_ret.data.avatar_source;
       doc.profile_avatar = account_info_ret.data.profile_avatar;
+      doc.verify_level = account_info_ret.data.verify_level;
       doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
     }
     doc.icon_pattern = await get_contact_pattern(doc);
@@ -4665,6 +4611,7 @@ export const get_pending_contact_in = async function (uid, _id) {
       doc.account_type = account_info_ret.data.account_type;
       doc.avatar_source = account_info_ret.data.avatar_source;
       doc.profile_avatar = account_info_ret.data.profile_avatar;
+      doc.verify_level = account_info_ret.data.verify_level;
       doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
     }
     doc.card_background = get_contact_background({ pending: true });
@@ -4704,6 +4651,7 @@ const get_user_contact = async function (uid, uid_query) {
   doc.profile_avatar = account_info.profile_avatar;
   doc.profile_picture = account_info.profile_picture;
   doc.avatar_source = account_info.avatar_source;
+  doc.verify_level = account_info.verify_level;
   doc.card_background = get_contact_background(doc);
   doc.icon_pattern = await get_contact_pattern(doc);
   doc.border = get_contact_border(doc);
@@ -5618,28 +5566,18 @@ setTimeout(async () => {
 
 //////// CONTACTS  //////////////
 
-function identifyPersonalProvider(domain) {
-  const providers = {
-    'gmail.com': 'Google Gmail',
-    'googlemail.com': 'Google Gmail',
-    'outlook.com': 'Microsoft Outlook',
-    'hotmail.com': 'Microsoft Hotmail',
-    'live.com': 'Microsoft Live',
-    'yahoo.com': 'Yahoo Mail',
-    'ymail.com': 'Yahoo Mail',
-    'aol.com': 'AOL Mail',
-    'icloud.com': 'Apple iCloud',
-    'me.com': 'Apple iCloud',
-    'mac.com': 'Apple iCloud',
-    'protonmail.com': 'ProtonMail',
-    'proton.me': 'ProtonMail',
-    'zoho.com': 'Zoho Mail',
-    'yandex.com': 'Yandex Mail',
-    'mail.com': 'Mail.com',
-    'gmx.com': 'GMX Mail',
-  };
+// A "business" that resolves to the address's own mail provider is not the contact's
+// employer, it is Gmail. get_business_info, handed a bare gmail.com address, answers
+// "Gmail / gmail.com / Technology" rather than "Not available", so the only escape hatch the
+// classification had (business_name === 'Not available') never fired and every personal
+// Gmail contact came out as a business, storefront placeholder and all. This is the second
+// escape hatch, built on the provider list that already exists directly below.
+const businessIsJustTheMailProvider = (business_info) => !!identifyPersonalProvider(business_info?.business_domain || '');
 
-  return providers[domain.toLowerCase()];
+function identifyPersonalProvider(domain) {
+  // The list moved to common so ai_module's contact classifier reads the same one. It used to
+  // live here alone, which is exactly why the classifier could call gmail.com a business.
+  return _common.personal_email_provider(domain);
 }
 
 export const add_contact = async function (req, job_id, headers) {
@@ -5714,21 +5652,24 @@ export const add_contact = async function (req, job_id, headers) {
           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);
+          const verdict = await ai_ms.is_business_contact(uid, email, name, metadata.subject, metadata.summarized_body, account_profile_info);
+          // Tolerates the old bare boolean, in case a stale ai_module answers this call.
+          const is_business = typeof verdict === 'object' && verdict !== null ? verdict.is_business : !!verdict;
           account_type = is_business ? 'business' : 'personal';
-          await activity('classified', { by: 'ai', account_type, inputs: { email: email.toLowerCase(), name: name || '', subject: metadata.subject || '' } });
+          await activity('classified', { by: 'ai', account_type, confidence: verdict?.confidence, why: verdict?.reason, 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') {
+            if (business_info.business_name !== 'Not available' && !businessIsJustTheMailProvider(business_info)) {
               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 {
+              const provider = identifyPersonalProvider(business_info?.business_domain || '');
               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' });
+              await activity('classified', { by: 'ai', account_type, reverted_from: 'business', reason: provider ? `the only business behind the address is its mail provider (${provider})` : 'no business could be identified behind the address' });
             }
           }
           if (_.isEmpty(cached_contact) && account_type === 'business' && !business_has_person) {
@@ -6372,19 +6313,31 @@ export const not_spam_contact = async function (req, job_id, headers) {
     }
 
     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);
+    const verdict = 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);
+    const is_business = typeof verdict === 'object' && verdict !== null ? verdict.is_business : !!verdict;
     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' });
+    await log_contact_activity(uid, contact_id, 'classified', { by: 'ai', trigger: 'not spam', account_type: contact_doc.account_type, confidence: verdict?.confidence, why: verdict?.reason, previous_account_type: previous_account_type || 'unset' });
+    if (!is_business && (contact_doc.business_info || contact_doc.business_has_person)) {
+      // A contact that reclassifies from business to person used to keep the company profile
+      // the old verdict attached to it, because business_info is only ever written inside the
+      // is_business branch and nothing clears it on the way out. The card then showed a person
+      // with a company still on file.
+      const dropped = contact_doc?.business_info?.business_name;
+      contact_doc.business_info = undefined;
+      contact_doc.business_has_person = undefined;
+      await log_contact_activity(uid, contact_id, 'business_info_cleared', { reason: 'contact reclassified as a person', dropped });
+    }
     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') {
+      if (contact_doc.business_info.business_name !== 'Not available' && !businessIsJustTheMailProvider(contact_doc.business_info)) {
         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 {
+        const provider = identifyPersonalProvider(contact_doc.business_info?.business_domain || '');
         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' });
+        await log_contact_activity(uid, contact_id, 'classified', { by: 'ai', account_type: 'personal', reverted_from: 'business', reason: provider ? `the only business behind the address is its mail provider (${provider})` : 'no business could be identified behind the address' });
       }
     }
 
@@ -6471,14 +6424,15 @@ export const set_deep_research_contact = async function (req, job_id, headers) {
 
     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') {
+      if (contact_doc.business_info.business_name !== 'Not available' && !businessIsJustTheMailProvider(contact_doc.business_info)) {
         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 {
+        const provider = identifyPersonalProvider(contact_doc.business_info?.business_domain || '');
         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' });
+        await log_contact_activity(uid, contact_id, 'classified', { by: 'ai', account_type: 'personal', reverted_from: 'business', reason: provider ? `the only business behind the address is its mail provider (${provider})` : 'deep research found no business behind the address' });
       }
     }
 
@@ -6568,7 +6522,16 @@ export const get_contact_activity = async function (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);
+    // get_app_couch_doc_native THROWS a bare couch 'missing' for an id that is not in
+    // this account's app db (an id from another account is the common way to get here),
+    // so the not-found check below never ran and the caller saw "missing" with nothing
+    // to act on. Catch it and answer the question that was actually asked.
+    let contact_doc;
+    try {
+      contact_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, contact_id);
+    } catch (_) {
+      contact_doc = null;
+    }
     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');
 
@@ -6688,7 +6651,11 @@ export const get_account_profile_info = async function (uid, contact_profile_doc
 
   const get_pattern = async function (doc) {
     // Same level-based default as get_contact_pattern, so a card shows the same
-    // verification tile whichever path built it.
+    // verification tile whichever path built it, and the same two states that
+    // outrank a level: a shared profile wears its owner's avatar, spam says
+    // spam. A business profile used to paint its own logo across the card face,
+    // which is why a verified business showed no level at all; the logo is
+    // already the avatar on the same card, so the tile is the level here too.
     let ret = level_pattern(doc);
 
     if (doc.shared_from_uid) {
@@ -6697,26 +6664,6 @@ export const get_account_profile_info = async function (uid, contact_profile_doc
       ret = shared_from_uid_ret.data.profile_avatar;
     } else if (doc.is_spam) {
       ret = `spam-pattern.png`;
-    } else if (doc.account_type === 'business') {
-      ret = doc.profile_picture;
-    } else {
-      switch (doc.avatar_source) {
-        case 'fictional':
-          ret = `fictional-avatar-pattern.png`;
-          break;
-
-        case 'ai profile':
-          ret = `fictional-avatar-pattern.png`;
-          break;
-
-        case 'authentic profile':
-          ret = `authentic-avatar-pattern.png`;
-          break;
-
-        default:
-          ret = `xu-pattern.png`;
-          break;
-      }
     }
 
     return ret;
@@ -6774,6 +6721,10 @@ export const get_account_profile_info = async function (uid, contact_profile_doc
   // console.log(stringToColour('Project Z')); // -> Consistent color for "Project Z"
 
   doc.avatar_source = account_info_ret.data.avatar_source;
+  // A profile inherits the verification level of the account that owns it (a
+  // shared profile, the account that shared it), so its card reads the same
+  // level as its owner's contact card instead of falling back to L0.
+  doc.verify_level = account_info_ret.data.verify_level;
   doc.icon_pattern = await get_pattern(doc);
   doc.name = doc.profile_name;
   doc.interactions = 0;
@@ -7888,9 +7839,11 @@ const _list_owner_members = async function (owner_uid, profiles) {
       const acc = await db_module.get_couch_doc_native('xuda_accounts', u);
       const ai = acc?.account_info || {};
       const name = ai.account_type === 'business' ? ai.business_name || 'Member' : `${ai.first_name || ''} ${ai.last_name || ''}`.trim() || ai.email || 'Member';
-      out.push({ uid: u, name });
+      // owner is reported (UI-163) so the member card can say so without the
+      // dashboard having to infer it from the order of this list.
+      out.push({ uid: u, name, owner: u === owner_uid });
     } catch (e) {
-      out.push({ uid: u, name: 'Member' });
+      out.push({ uid: u, name: 'Member', owner: u === owner_uid });
     }
   }
   return out;
@@ -7931,7 +7884,139 @@ export const get_credit_management = async function (req) {
     const profiles = await _list_owner_profiles(uid, app_id, account_doc?.account_profile_id);
     const members = await _list_owner_members(uid, profiles);
 
-    return { code: 1, data: { rules, can_edit, plan, entitlements, usage_breakdown, model_catalog, profiles, members } };
+    // main_profile_id is reported (UI-163) so the spend chart can name the
+    // owner's own profile: it is deliberately absent from `profiles` (no member
+    // to scope a rule to), and without the id its spend can only be labelled
+    // "some other profile".
+    return { code: 1, data: { rules, can_edit, plan, entitlements, usage_breakdown, model_catalog, profiles, members, main_profile_id: account_doc?.account_profile_id || '' } };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+/////////////////////////////////////////////////////////////////////////
+// USAGE HISTORY (UI-163)
+//
+// The drill-down behind the "N credits used" line on a profile or member card:
+// day by day spend, which models it went on, and the calls themselves. It reads
+// the same raw ai_usage docs _get_scoped_usage aggregates, and calibrates them
+// the same way, so a card's total and its history cannot tell two stories.
+//
+// Calibration: raw token cost is not the credit unit the ledger reports, so the
+// scan also covers the CURRENT PERIOD and the two totals give the conversion
+// factor (authoritative period spend / raw period cost). That is a unit
+// conversion, so it holds for any window inside the scan.
+/////////////////////////////////////////////////////////////////////////
+const _CREDIT_HISTORY_MAX_DOCS = 20000;
+const _CREDIT_HISTORY_MAX_DAYS = 180;
+const _CREDIT_HISTORY_SCAN_DAYS = 120;
+const _DAY_MS = 86400000;
+const _utc_day = function (ts) {
+  return new Date(ts).toISOString().slice(0, 10);
+};
+const _raw_usage_cost = function (doc) {
+  const c = doc?.cost || { input: 1, output: 1 };
+  return ((Number(doc?.input_tokens) || 0) * (Number(c.input) || 0) + (Number(doc?.output_tokens) || 0) * (Number(c.output) || 0)) / 1e6;
+};
+
+export const get_credit_usage_history = async function (req) {
+  try {
+    const uid = req?.uid || req?.token_ret?.data?.uid;
+    if (!uid) return { code: -1, data: 'not authorized' };
+
+    const scope = ['profile', 'user'].includes(req?.scope) ? req.scope : 'account';
+    const id = typeof req?.id === 'string' ? req.id : '';
+    if (scope !== 'account' && !id) return { code: -1, data: 'id is required for a profile or member history' };
+
+    let days = Math.round(Number(req?.days) || 30);
+    if (!(days >= 1)) days = 30;
+    days = Math.min(_CREDIT_HISTORY_MAX_DAYS, days);
+
+    const account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+    const period = _current_credit_period(account_doc);
+
+    // UTC day buckets, so the series is the same series wherever it is read.
+    const today_start = Math.floor(Date.now() / _DAY_MS) * _DAY_MS;
+    const window_from = today_start - (days - 1) * _DAY_MS;
+    // Reach back to the period start even when the window is shorter (the factor
+    // needs it), but never further than the scan bound: a yearly period must not
+    // turn one drill-down into a full-history scan.
+    const scan_from = Math.max(Math.min(window_from, period.start), today_start - _CREDIT_HISTORY_SCAN_DAYS * _DAY_MS);
+
+    // ignore_warning=true: same nested selector as _get_scoped_usage, and the
+    // same index note applies (an index on account_profile_info.uid before any
+    // prod rollout).
+    const raw = await db_module.find_couch_query(
+      'xuda_usage',
+      {
+        selector: { docType: 'ai_usage', 'account_profile_info.uid': uid, date_created_ts: { $gte: scan_from } },
+        fields: ['date_created_ts', 'uid', 'model', 'source', 'prompt', 'input_tokens', 'output_tokens', 'cost', 'account_profile_info.account_profile_id'],
+        limit: _CREDIT_HISTORY_MAX_DOCS,
+      },
+      true,
+    );
+    const docs = raw?.docs || [];
+
+    let raw_period_total = 0;
+    for (const d of docs) if ((Number(d.date_created_ts) || 0) >= period.start) raw_period_total += _raw_usage_cost(d);
+    const su = await _get_scoped_usage(uid, false);
+    const factor = raw_period_total > 0 && su.total > 0 ? su.total / raw_period_total : 1;
+
+    const in_scope = function (d) {
+      if (scope === 'profile') return d?.account_profile_info?.account_profile_id === id;
+      if (scope === 'user') return d?.uid === id;
+      return true;
+    };
+
+    const series = {};
+    for (let t = window_from; t <= today_start; t += _DAY_MS) series[_utc_day(t)] = 0;
+
+    const by_model = {};
+    const events = [];
+    let total = 0;
+    for (const d of docs) {
+      const ts = Number(d.date_created_ts) || 0;
+      if (ts < window_from || !in_scope(d)) continue;
+      const credits = _raw_usage_cost(d) * factor;
+      total += credits;
+      const day = _utc_day(ts);
+      if (day in series) series[day] += credits;
+      const code = _conf.ai_model_aliases?.[d.model] || d.model || 'unknown';
+      by_model[code] = (by_model[code] || 0) + credits;
+      events.push({
+        ts,
+        credits,
+        model: code,
+        model_name: _conf.ai_models?.[code]?.name || d.model || code,
+        source: d.source || 'other',
+        uid: d.uid || '',
+        account_profile_id: d?.account_profile_info?.account_profile_id || '',
+        prompt: typeof d.prompt === 'string' ? d.prompt : '',
+      });
+    }
+    events.sort((a, b) => b.ts - a.ts);
+
+    const r2 = (n) => Math.round(n * 100) / 100;
+    return {
+      code: 1,
+      data: {
+        scope,
+        id,
+        days,
+        total: r2(total),
+        calls: events.length,
+        // The scan is capped, so say so rather than quietly reporting a partial
+        // history as the whole of it.
+        truncated: docs.length >= _CREDIT_HISTORY_MAX_DOCS,
+        series: Object.keys(series)
+          .sort()
+          .map((day) => ({ day, credits: r2(series[day]) })),
+        by_model: Object.entries(by_model)
+          .map(([code, credits]) => ({ code, name: _conf.ai_models?.[code]?.name || code, credits: r2(credits) }))
+          .sort((a, b) => b.credits - a.credits),
+        events: events.slice(0, 60).map((e) => ({ ...e, credits: Math.round(e.credits * 10000) / 10000 })),
+      },
+    };
   } catch (err) {
     return { code: -1, data: err.message };
   }
@@ -9205,7 +9290,10 @@ const _newsletter_blast = async (issue, by_uid) => {
   } catch (e) {
     console.error('[newsletter] finalize failed:', e.message);
   }
-  _ops_notify_ops(`Newsletter #${issue.issue_number} published`, [['Issue', '#' + issue.issue_number], ['Sent', sent], ['Failed', failed], ['Recipients', total]], 'NL-DONE-' + issue.issue_number);
+  // No ops notification on completion: the "Publishing newsletter #N" alert
+  // already announces the blast, and the result lands on the issue doc
+  // (sent.count / sent.failed) plus the log line below.
+  console.log(`[newsletter] #${issue.issue_number} published: sent=${sent} failed=${failed} recipients=${total}`);
 };
 
 export const newsletter_publish = async function (req = {}) {

package/index_ms.mjs

@@ -541,6 +541,10 @@ export const get_credit_management = async function (...args) {
   return await broker.send_to_queue("get_credit_management", ...args);
 };
 
+export const get_credit_usage_history = async function (...args) {
+  return await broker.send_to_queue("get_credit_usage_history", ...args);
+};
+
 export const set_credit_rules = async function (...args) {
   return await broker.send_to_queue("set_credit_rules", ...args);
 };

package/index_msa.mjs

@@ -541,6 +541,10 @@ export const get_credit_management =  function (...args) {
    broker.send_to_queue_async("get_credit_management", ...args);
 };
 
+export const get_credit_usage_history =  function (...args) {
+   broker.send_to_queue_async("get_credit_usage_history", ...args);
+};
+
 export const set_credit_rules =  function (...args) {
    broker.send_to_queue_async("set_credit_rules", ...args);
 };

package/package.json

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