@xuda.io/ai_module 1.1.5640 → 1.1.5642

package/index.mjs

@@ -308,11 +308,37 @@ const { init, check, check_structure, get_zod_schema, get_fields_z_schema } = aw
 const { get_xuda_couch } = _common;
 
 const db_module = await import(`${module_path}/db_module/index.mjs`);
+
+// Sort keys for the dashboard list tabs, per docType. Each entry is a fallback
+// chain (first defined value wins) because the doc shapes differ: a chat has
+// its own title + date_created_ts, a studio doc carries the name under
+// properties.menuName and may only have ts. See
+// db_module.find_app_couch_sorted_page.
+// `shared` points at the owner's copy: an app/agent shared with you, or bought
+// from the marketplace, is stored locally as a stub with no menuName, so a name
+// sort has to read the source doc. Same two pointers the enrichment follows
+// (get_ai_agents/get_apps: shared_from_app_id + share_item_id, then
+// installed_from_app_id keyed by the doc's own _id).
+const LIST_SORT_PATHS = {
+  chat: { created: ['date_created_ts', 'date_created', 'ts'], updated: ['ts', 'date_created_ts'], name: ['title'] },
+  studio: {
+    created: ['date_created_ts', 'date_created', 'ts'],
+    updated: ['ts', 'date_created_ts'],
+    name: ['properties.menuName', 'studio_meta.name'],
+    shared: [
+      { app_id: 'studio_meta.shared_from_app_id', doc_id: 'studio_meta.share_item_id' },
+      { app_id: 'studio_meta.installed_from_app_id', doc_id: '_id' },
+    ],
+  },
+};
+
 const account_ms = await import(`${module_path}/account_module/index_ms.mjs`);
 const drive_ms = await import(`${module_path}/drive_module/index_ms.mjs`);
 const jobs_ms = await import(`${module_path}/jobs_module/index_ms.mjs`);
 const team_ms = await import(`${module_path}/team_module/index_ms.mjs`);
 const email_ms = await import(`${module_path}/email_module/index_ms.mjs`);
+// Profile broadcasts send SMS through the same primitive Phone Manager uses.
+const voice_ms = await import(`${module_path}/voice_module/index_ms.mjs`);
 const api_ms = await import(`${module_path}/api_module/index_ms.mjs`);
 const stripe_ms = await import(`${module_path}/stripe_module/index_ms.mjs`);
 
@@ -2073,6 +2099,14 @@ export const get_ai_chats = async function (req, job_id, headers) {
         };
       }
 
+      // User-picked order from the dashboard list controls (sort_by date |
+      // updated | name, sort_dir asc | desc). Null when none was asked for,
+      // which leaves the default newest-first path below untouched. Only the
+      // top-level chat list is sortable: with a reference_id these are the
+      // items INSIDE one conversation, which must stay in thread order.
+      const sorted = reference_id || conversation_id ? null : await db_module.find_app_couch_sorted_page(account_profile_info.app_id, opt, req, LIST_SORT_PATHS.chat);
+      if (sorted) return sorted;
+
       let ai_chats = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
       if (!limit || conversation_id) {
         ai_chats.total_docs = ai_chats.docs.length;
@@ -2243,9 +2277,19 @@ export const get_ai_chats = async function (req, job_id, headers) {
       doc.notifications = contact_chat_conversation_count_ret[doc._id] - contact_chat_conversation_read_ret[doc._id];
       doc.chats = doc.interactions;
 
-      doc.user_contact = await get_user_card({ uid, uid_query: doc.uid });
+      // Who WROTE this row. A contact/profile timeline comes back from
+      // get_data_view_conversation_items as a composite { conversation, conversation_item }
+      // that carries no uid of its own, so `doc.uid` was undefined here. get_user_card then
+      // built a selector with contact_uid dropped (JSON.stringify strips undefined) and
+      // matched ANY contact, which is why every note on a contact page was bylined with the
+      // first contact in the book, the person the note is ABOUT, instead of its author.
+      const author_uid = doc.uid || doc.conversation_item?.uid || doc.conversation?.initiator_uid || doc.conversation?.uid;
+
+      if (author_uid) {
+        doc.user_contact = await get_user_card({ uid, uid_query: author_uid });
+      }
 
-      doc.privilege = doc.uid === uid || doc?.account_profile_info?.uid === uid;
+      doc.privilege = author_uid === uid || doc?.account_profile_info?.uid === uid;
 
       if (reference_id && doc.reference_type === 'contact') {
         // only valid for contacts conversation
@@ -2254,6 +2298,17 @@ export const get_ai_chats = async function (req, job_id, headers) {
       docs.push(doc);
     }
 
+    // Calls and SMS belong on the contact's timeline next to the notes rather than behind
+    // their own tabs, so merge them in and order the whole thing by time. Only for a real
+    // contact timeline: the account-wide lists have their own screens.
+    if (reference_id && reference_type === 'contacts') {
+      const voice_rows = await _tl_voice_rows(uid, account_profile_info, reference_id, docs[0]?.user_contact || null);
+      if (voice_rows.length) {
+        const row_ts = (r) => Number(r?.conversation_item?.date_created_ts || r?.conversation?.date_created_ts || r?.date_created_ts || 0);
+        docs = [...docs, ...voice_rows].sort((a, b) => row_ts(a) - row_ts(b));
+      }
+    }
+
     return { code: 2, data: { docs: [...requests_from.docs, ...docs], total_docs: ai_chats.total_docs + requests_from.total_docs } };
   } catch (err) {
     return { code: -2, data: err.message };
@@ -2974,17 +3029,24 @@ export const get_ai_agents = async function (req, job_id, headers) {
 
     let user_agents = { docs: [], total_docs: 0 };
     if (filter_type !== 'pending') {
-      user_agents = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
-      if (!limit || agent_id) {
-        user_agents.total_docs = user_agents.docs.length;
+      // User-picked order from the dashboard list controls, see
+      // db_module.find_app_couch_sorted_page. Null when none was asked for.
+      const sorted = agent_id ? null : await db_module.find_app_couch_sorted_page(account_profile_info.app_id, opt, req, LIST_SORT_PATHS.studio);
+      if (sorted) {
+        user_agents = sorted;
       } else {
-        delete opt.sort;
-        delete opt.skip;
-        opt.limit = 9999;
-        opt.fields = ['_id'];
+        user_agents = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
+        if (!limit || agent_id) {
+          user_agents.total_docs = user_agents.docs.length;
+        } else {
+          delete opt.sort;
+          delete opt.skip;
+          opt.limit = 9999;
+          opt.fields = ['_id'];
 
-        const counter = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
-        user_agents.total_docs = counter.docs.length;
+          const counter = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
+          user_agents.total_docs = counter.docs.length;
+        }
       }
     }
 
@@ -3460,17 +3522,25 @@ export const get_apps = async function (req, job_id, headers) {
 
     let user_apps = { docs: [], total_docs: 0 };
     if (filter_type !== 'pending') {
-      user_apps = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
-      if (!limit || mini_app_id) {
-        user_apps.total_docs = user_apps.docs.length;
+      // User-picked order from the dashboard list controls, see
+      // db_module.find_app_couch_sorted_page. Null when none was asked for,
+      // which leaves the default newest-first path below untouched.
+      const sorted = mini_app_id ? null : await db_module.find_app_couch_sorted_page(account_profile_info.app_id, opt, req, LIST_SORT_PATHS.studio);
+      if (sorted) {
+        user_apps = sorted;
       } else {
-        delete opt.sort;
-        delete opt.skip;
-        opt.limit = 9999;
-        opt.fields = ['_id'];
+        user_apps = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
+        if (!limit || mini_app_id) {
+          user_apps.total_docs = user_apps.docs.length;
+        } else {
+          delete opt.sort;
+          delete opt.skip;
+          opt.limit = 9999;
+          opt.fields = ['_id'];
 
-        const counter = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
-        user_apps.total_docs = counter.docs.length;
+          const counter = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
+          user_apps.total_docs = counter.docs.length;
+        }
       }
     }
 
@@ -5143,6 +5213,103 @@ const process_conversation = async function (uid, conversation_id, account_profi
   // }
 };
 
+// --- contact timeline: calls and SMS -----------------------------------------------------
+// Phone activity lives in xuda_master as voice_call / voice_message docs keyed by
+// owner_uid + phone number, NOT by contact, so it can only be tied to a contact by matching
+// numbers. Digits only, comparing the last 10, so a number written +1 561 235 1675 on an
+// account matches +15612351675 on a call. Same rule as voice_module's own caller matching.
+const _tl_digits = (value) => String(value ?? '').replace(/\D+/g, '');
+const _tl_same_phone = (a, b) => {
+  const x = _tl_digits(a);
+  const y = _tl_digits(b);
+  if (!x || !y) return false;
+  if (x === y) return true;
+  const n = Math.min(10, x.length, y.length);
+  return n >= 7 && x.slice(-n) === y.slice(-n);
+};
+
+// Every number this contact can be reached on. A contact linked to a Xuda user carries no
+// phone on its own doc at all: it lives on their account, which is why matching only the
+// contact doc finds nothing for exactly the contacts that matter most.
+const _tl_contact_phones = async function (app_id, contact_id) {
+  const out = [];
+  let contact = null;
+  try {
+    contact = await db_module.get_app_couch_doc_native(app_id, contact_id);
+    for (const f of ['phone_e164', 'phone', 'telephone', 'phone_number', 'mobile', 'tel']) {
+      if (contact?.[f]) out.push(contact[f]);
+    }
+    if (contact?.contact_uid) {
+      const ret = await db_module.get_couch_doc('xuda_accounts', contact.contact_uid);
+      const info = ret?.code >= 0 ? ret.data?.account_info || {} : {};
+      if (info.phone_number) out.push(info.phone_number);
+      if (info.tel) out.push(info.tel);
+    }
+  } catch (_) { /* no phone is a normal contact, not an error */ }
+  return { phones: out.filter(Boolean), contact };
+};
+
+// Calls and SMS as timeline rows, in the same composite shape the note and email rows use
+// ({ conversation, conversation_item, user_contact }) so the timeline renders them by
+// conversation_type without a second code path.
+const _tl_voice_rows = async function (uid, account_profile_info, contact_id, user_contact) {
+  try {
+    const { phones, contact } = await _tl_contact_phones(account_profile_info.app_id, contact_id);
+    if (!phones.length) return [];
+    const peer = (d) => (d.direction === 'inbound' ? d.from : d.to);
+    // Byline the party who did the thing: an inbound call or SMS came FROM the contact, an
+    // outbound one went out under this account. Bylining every call with the account name
+    // read as if the business had called itself.
+    const card_for = (d) => (d.direction === 'inbound' ? contact || user_contact : user_contact);
+    const [calls, messages] = await Promise.all([
+      db_module.find_couch_query('xuda_master', { selector: { docType: 'voice_call', owner_uid: uid }, limit: 500 }, false, true),
+      db_module.find_couch_query('xuda_master', { selector: { docType: 'voice_message', owner_uid: uid }, limit: 500 }, false, true),
+    ]);
+    const mine = (d) => phones.some((p) => _tl_same_phone(p, peer(d)));
+    const row = (type, doc, text, extra) => ({
+      conversation: { _id: doc._id, docType: 'chat_conversation', conversation_type: type, reference_type: 'contacts', reference_id: contact_id, uid, prompt: text, title: text, date_created_ts: doc.created_ts, ts: doc.created_ts, stat: 3 },
+      conversation_item: { _id: doc._id, docType: 'chat_conversation_item', conversation_type: type, type, text, direction: doc.direction, date_created_ts: doc.created_ts, ts: doc.created_ts, stat: 3, uid },
+      user_contact: card_for(doc),
+      voice: { kind: type, ...extra },
+      privilege: true,
+    });
+
+    // What the call was actually about, so the row says something beyond its duration.
+    // The caller's LONGEST turn, because the opening turns are "Hello?" and whatever noise
+    // the speech recogniser picked up before the greeting, while the request itself is the
+    // one sentence they actually spoke at length.
+    const call_gist = (d) => {
+      const turns = Array.isArray(d.transcript) ? d.transcript : [];
+      const said = turns
+        .filter((t) => t.role === 'caller' || t.role === 'user')
+        .map((t) => String(t.text || '').replace(/\s+/g, ' ').trim())
+        .filter(Boolean);
+      const text = said.sort((a, b) => b.length - a.length)[0] || '';
+      return text.length > 140 ? `${text.slice(0, 139)}…` : text;
+    };
+    // Stored as an object ({ type, id }) by the realtime path but sent as a plain string on
+    // the socket event, and the UI compares it to 'ai'. Normalize to the string form here so
+    // a row reads the same however the call was recorded.
+    const handled_kind = (d) => (typeof d.handled_by === 'object' && d.handled_by ? d.handled_by.type || '' : d.handled_by || '');
+    const call_rows = (calls?.docs || []).filter((d) => d.status !== 'ringing' && mine(d)).map((d) =>
+      row('call', d, d.direction === 'inbound' ? 'Incoming call' : 'Outgoing call', {
+        status: d.status,
+        duration_sec: d.duration_sec || 0,
+        has_recording: !!d.recording,
+        transcript_turns: (d.transcript || []).length,
+        transcript_preview: call_gist(d),
+        handled_by: handled_kind(d),
+      }),
+    );
+    const sms_rows = (messages?.docs || []).filter(mine).map((d) => row('sms', d, d.body || '', { status: d.status, segments: d.segments || 1 }));
+    return [...call_rows, ...sms_rows];
+  } catch (err) {
+    // A phone lookup must never take the whole timeline down with it.
+    console.error('[ai_module] contact voice timeline rows failed:', err.message);
+    return [];
+  }
+};
+
 const contactGuardrailAgent = new Agent({
   name: 'Person Guardrail check',
   instructions: 'Check if the prompt about person.',
@@ -5256,7 +5423,23 @@ export const submit_chat_conversation = async function (req, job_id, headers) {
       }
 
       case 'account_profiles': {
-        ret = await ai_chat_conversation(req, job_id, headers);
+        // This used to call ai_chat_conversation unconditionally, so Note, Chat, SMS and
+        // Email on a profile all silently became AI chats. A profile thread is a group
+        // thread: each mode records one item here, and the broadcast modes also deliver
+        // to every member. See profile_thread_post.
+        switch (conversation_doc.conversation_type) {
+          case 'note':
+          case 'chat':
+          case 'sms':
+          case 'email': {
+            ret = await profile_thread_post(req, job_id, headers, conversation_doc.conversation_type);
+            break;
+          }
+          default: {
+            ret = await ai_chat_conversation(req, job_id, headers);
+            break;
+          }
+        }
         break;
       }
 
@@ -5428,6 +5611,149 @@ const chat_note = async function (req, job_id, headers) {
   }
 };
 
+// ── Account-profile group thread ────────────────────────────────────────────────────────
+// A profile conversation is ONE group thread, not a set of per-member threads (Boaz,
+// 2026-07-31: "only on the profile like group chat"). Every mode records a single item on
+// the profile conversation. SMS and email additionally deliver that text to each member,
+// but those sends are a delivery detail: nothing is written to a member's own contact
+// timeline, and inbound replies belong back on this same profile conversation.
+
+// Resolve the profile's members to one delivery address each, then send per member.
+// Returns a per-recipient outcome rather than a bare boolean, because a broadcast that
+// only half-succeeded must not be recorded as if it had reached everyone.
+const profile_broadcast_recipients = async function (owner_uid, profile_id, kind) {
+  const member_uids = await account_ms.get_account_profile_group_member_uids(owner_uid, profile_id);
+  // The owner is not a member of their own profile and must not receive their own broadcast.
+  const uids = [...new Set((member_uids || []).filter((u) => u && u !== owner_uid))];
+  const out = [];
+  for (const member_uid of uids) {
+    let doc = null;
+    try {
+      doc = await db_module.get_couch_doc_native('xuda_accounts', member_uid);
+    } catch (_) {
+      doc = null;
+    }
+    const info = doc?.account_info || {};
+    const name = [info.name, info.last_name].filter(Boolean).join(' ') || info.email || member_uid;
+    const address = kind === 'sms' ? info.phone_number : info.email;
+    out.push({ uid: member_uid, name, address: address || null });
+  }
+  return out;
+};
+
+const profile_broadcast = async function (uid, account_profile_info, profile_id, kind, body) {
+  const recipients = await profile_broadcast_recipients(uid, profile_id, kind);
+  const results = [];
+
+  // One SMS-capable number for the whole broadcast, resolved once. Without a number there
+  // is nothing to send from, and that is a configuration error worth surfacing rather than
+  // reporting every member as individually unreachable.
+  let voice_number_id = null;
+  if (kind === 'sms') {
+    const numbers = await voice_ms.list_voice_numbers({ uid, profile_id });
+    const usable = (numbers?.data || []).find((n) => n.capabilities?.SMS === true || n.capabilities?.sms === true);
+    if (!usable) throw new Error('This profile has no phone number that can send SMS');
+    voice_number_id = usable.id;
+  }
+
+  const profile_name = account_profile_info.account_profile_obj?.profile_name || 'your team';
+  for (const recipient of recipients) {
+    if (!recipient.address) {
+      results.push({ ...recipient, ok: false, error: kind === 'sms' ? 'no phone number on file' : 'no email address on file' });
+      continue;
+    }
+    try {
+      if (kind === 'sms') {
+        const ret = await voice_ms.send_voice_message({ uid, profile_id, voice_number_id, to: recipient.address, body });
+        if (ret?.code < 0) throw new Error(ret.data || 'send failed');
+      } else {
+        await email_ms.send_email({
+          email: recipient.address,
+          subject: `Message from ${profile_name}`,
+          body,
+          display_type: 'info',
+          app_id: account_profile_info.app_id,
+        });
+      }
+      results.push({ ...recipient, ok: true });
+    } catch (err) {
+      results.push({ ...recipient, ok: false, error: err.message });
+    }
+  }
+
+  return { results, sent: results.filter((r) => r.ok).length, failed: results.filter((r) => !r.ok).length };
+};
+
+// `kind` is the composer mode: note | chat | sms | email. AI chat does not come through
+// here, it keeps going to ai_chat_conversation.
+const profile_thread_post = async function (req, job_id, headers, kind) {
+  const { uid, profile_id } = req;
+  const account_profile_info = await get_active_account_profile_info(uid, profile_id);
+  const { prompt: body, conversation_doc, attachments = [] } = req;
+  try {
+    const conversation_id = conversation_doc._id;
+    const app_id = account_profile_info.app_id;
+    const text = String(body || '').trim();
+    if (!text) throw new Error('A message body is required');
+
+    await attachment_handler(uid, app_id, conversation_id, attachments, account_profile_info);
+
+    // Deliver BEFORE recording. A thread item is a claim that the message went out, so a
+    // broadcast that reached nobody has to fail loudly instead of leaving a row that reads
+    // as sent. A partial success is recorded, with the per-recipient detail on the item.
+    let delivery = null;
+    if (kind === 'sms' || kind === 'email') {
+      delivery = await profile_broadcast(uid, account_profile_info, conversation_doc.reference_id, kind, text);
+      if (!delivery.sent) {
+        const why = delivery.results.find((r) => r.error)?.error;
+        throw new Error(delivery.failed ? `Could not deliver to any member (${why})` : 'This profile has no members to send to');
+      }
+    }
+
+    let conversation_item_reference_id;
+    try {
+      conversation_item_reference_id = await add_conversation_item(uid, profile_id, conversation_id, text, kind, conversation_doc.reference_id, {});
+      report_ai_status('conversations');
+    } catch (err) {
+      report_ai_status('conversations', err);
+      throw err;
+    }
+
+    const out_conversation_item_obj = {
+      _id: await _common.xuda_get_uuid('chat_conversation_item'),
+      stat: 3,
+      docType: 'chat_conversation_item',
+      uid,
+      conversation_type: kind,
+      type: kind,
+      date_created_ts: Date.now(),
+      ts: Date.now(),
+      conversation_id,
+      text,
+      reference_id: conversation_doc.reference_id,
+      conversation_item_reference_id,
+      direction: 'out',
+      role: 'user',
+      read: { [uid]: Date.now() },
+      rtl: _common.detectRTL(text),
+      ...(delivery
+        ? {
+            broadcast: {
+              channel: kind,
+              sent: delivery.sent,
+              failed: delivery.failed,
+              recipients: delivery.results.map((r) => ({ uid: r.uid, name: r.name, ok: r.ok, ...(r.error ? { error: r.error } : {}) })),
+            },
+          }
+        : {}),
+    };
+
+    return await db_module.save_app_couch_doc(app_id, out_conversation_item_obj);
+  } catch (err) {
+    return { code: -15, data: err.message };
+  }
+};
+
 const chat_email = async function (req, job_id, headers) {
   const { profile_id, uid, email_id, perform_ai_execution = true, from_mailbox, _thread_reentry, direction } = req;
   const account_profile_info = await get_active_account_profile_info(uid, profile_id);

package/package.json

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