@xuda.io/ai_module 1.1.5641 → 1.1.5642

package/index.mjs

@@ -337,6 +337,8 @@ 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`);
 
@@ -5272,13 +5274,31 @@ const _tl_voice_rows = async function (uid, account_profile_info, contact_id, us
       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,
-        handled_by: d.handled_by || '',
+        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 }));
@@ -5403,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;
       }
 
@@ -5575,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.5641",
+  "version": "1.1.5642",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",