@xuda.io/ai_module 1.1.5641 → 1.1.5643

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);
@@ -7077,64 +7256,18 @@ const get_ai_agent_tools = async function ({ ai_agent_doc, agent_id, reference_t
   let tool_resources = {};
   let eligible_agent = true;
 
-  const add_internal_codex_tool = function ({ name, description, system_prompt }) {
+  const add_xuda_public_website_tool = function ({ name, description, origin, path_prefix }) {
     if (reference_type !== 'ai_agents' && !prompt_suggestion_activated && !chat_suggestion_activated) {
       eligible_agent = false;
       return;
     }
 
-    tools.push(
-      tool({
-        name: name.substring(0, 60),
-        description,
-        parameters: z.object({
-          question: z.string().describe('The support question to investigate.'),
-        }),
-        async execute(e) {
-          const question = String(e?.question || '').trim();
-          if (!question) {
-            return 'question is required';
-          }
-
-          const dev_host = _conf?.internal_ai_agents?.dev_server_host || 'dev.xuda.ai';
-          const codex_ret = await execute_codex_request(
-            {
-              ip: dev_host,
-              uid,
-              account_profile_info,
-              job_id,
-              stream: false,
-              prompt: `${system_prompt}
-
-User question:
-${question}
-
-Return a concise answer. Include only non-sensitive findings and mention when the requested information is outside the allowed scope.`,
-            },
-            job_id,
-            headers,
-          );
-
-          if (codex_ret.code < 0) {
-            return `Codex readonly lookup failed: ${get_error_message(codex_ret.data, 'unknown error')}`;
-          }
-
-          const events = codex_ret?.data?.events || [];
-          const final_message = [...events].reverse().find((event) => event?.item?.type === 'agent_message' && event.item.text)?.item?.text;
-          return final_message || 'Codex readonly lookup completed without a final answer.';
-        },
-      }),
-    );
-  };
-
-  const add_xuda_public_website_tool = function ({ name, description }) {
-    if (reference_type !== 'ai_agents' && !prompt_suggestion_activated && !chat_suggestion_activated) {
-      eligible_agent = false;
-      return;
-    }
-
-    const website_origin = _conf?.internal_ai_agents?.public_website_url || 'https://xuda.ai';
-    const dump_dir = path.join(os.tmpdir(), 'xuda_public_website_dump', new URL(website_origin).hostname.replace(/[^a-z0-9.-]/gi, '_'));
+    const website_origin = origin || _conf?.internal_ai_agents?.public_website_url || 'https://xuda.ai';
+    // path_prefix narrows the crawl to one section of the site (the mentor tool uses /docs).
+    // It is part of the cache key so a narrowed tool can never read a wider tool's dump.
+    const section = String(path_prefix || '').replace(/\/+$/, '');
+    const cache_key = `${new URL(website_origin).hostname}${section}`.replace(/[^a-z0-9.-]/gi, '_');
+    const dump_dir = path.join(os.tmpdir(), 'xuda_public_website_dump', cache_key);
     const manifest_path = path.join(dump_dir, 'manifest.json');
     const ttl_ms = Number(_conf?.internal_ai_agents?.public_website_dump_ttl_ms || 10 * 60 * 1000);
     const cache_version = 2;
@@ -7258,13 +7391,19 @@ Return a concise answer. Include only non-sensitive findings and mention when th
 
       await fs.promises.mkdir(dump_dir, { recursive: true });
       const sitemap_xml = await fetch_text(`${website_base}/sitemap.xml`, 8000);
-      const priority_urls = [`${website_base}/`, `${website_base}/about`, `${website_base}/legal/privacy-policy`, `${website_base}/legal/terms`, `${website_base}/contact`];
+      const priority_urls = section
+        ? [`${website_base}${section}/`]
+        : [`${website_base}/`, `${website_base}/about`, `${website_base}/legal/privacy-policy`, `${website_base}/legal/terms`, `${website_base}/contact`];
       const sitemap_urls = [...sitemap_xml.matchAll(/<loc>([\s\S]*?)<\/loc>/gi)]
         .map((match) => decode_html(match[1]).trim())
         .filter((url) => {
           try {
             const parsed = new URL(url);
-            return parsed.origin === website_base && !/\.(png|jpe?g|gif|webp|svg|pdf|zip)$/i.test(parsed.pathname);
+            if (parsed.origin !== website_base) return false;
+            // Section-scoped tools see only their own subtree, so a docs-only tool cannot
+            // wander into the rest of the site.
+            if (section && !(parsed.pathname === section || parsed.pathname.startsWith(`${section}/`))) return false;
+            return !/\.(png|jpe?g|gif|webp|svg|pdf|zip)$/i.test(parsed.pathname);
           } catch (_) {
             return false;
           }
@@ -7375,26 +7514,20 @@ Return a concise answer. Include only non-sensitive findings and mention when th
         break;
       }
 
-      case 'xuda_network_mentor_dev_server_readonly': {
-        add_internal_codex_tool({
-          name: name || 'Xuda Mentor Dev Server Readonly',
-          description: description || 'Readonly Codex lookup on /var/xuda of the dev server for technical mentor answers.',
-          system_prompt: `You are Codex helping a Xuda Network mentor answer technical questions about the Xuda codebase.
-
-Scope:
-- You may inspect only the dev server ${_conf?.internal_ai_agents?.dev_server_host || 'dev.xuda.ai'}.
-- You may use SSH only for readonly inspection.
-- You may read only under /var/xuda.
-- Prefer safe inspection commands such as pwd, ls, find, rg, sed -n, head, tail, wc, git status, git diff --stat, git log --oneline, and git show.
-
-Hard restrictions:
-- Never access config, config_dev, .env files, secret folders, SSH keys, certificates, credential files, database dumps, backups, logs likely to contain credentials, or any path outside /var/xuda.
-- Never query CouchDB or any database.
-- Never use network commands to call internal services.
-- Never run commands that write, mutate, install, delete, restart, deploy, publish, chmod/chown, kill processes, or change system state.
-- Never reveal passwords, tokens, API keys, private keys, names of private people, private emails, personal information, customer data, security details, or anything that could harm Xuda, its team, customers, or product security.
-- If the answer requires forbidden access, say it is outside the readonly mentor scope.
-- If sensitive data appears accidentally, do not quote it. State that sensitive output was omitted.`,
+      // RETIRED 2026-07-31 (Boaz): this used to run Codex over SSH on the dev server. Its
+      // "readonly" scope was only a system prompt, while the process itself ran with
+      // --dangerously-bypass-approvals-and-sandbox (no sandbox key is set in either config,
+      // and that is the default), so an external mentor chatting to the agent was one
+      // persuasive message away from arbitrary command execution on dev. The type string is
+      // KEPT and remapped rather than deleted, so every mentor agent already installed out
+      // there loses the capability the moment this ships, with no agent doc to migrate.
+      case 'xuda_network_mentor_dev_server_readonly':
+      case 'xuda_network_mentor_docs_readonly': {
+        add_xuda_public_website_tool({
+          name: name || 'Xuda Mentor Docs Readonly',
+          description: description || 'Readonly lookup against the public Xuda developer documentation for technical mentor answers.',
+          origin: _conf?.internal_ai_agents?.docs_website_url || _conf?.internal_ai_agents?.public_website_url || 'https://xuda.ai',
+          path_prefix: _conf?.internal_ai_agents?.docs_path_prefix || '/docs',
         });
         break;
       }
@@ -8504,6 +8637,20 @@ const add_conversation_item = async function (uid, profile_id, conversation_id,
   }
 };
 
+// The same privacy rule the phone AI follows, worded for a written reply. The contact may of
+// course see the thread they are already in, that is their own conversation. What they must
+// never get is the business's DERIVED view of them (internal notes, categories, mood or
+// status labels, payment standing), anything about a DIFFERENT contact, or a rundown of their
+// activity on other channels. Chat and SMS have no live verification step the way a phone
+// call does (there is nobody on the line to read a code back mid-sentence), so the verified
+// exception does not apply here and cross-channel history stays closed.
+const AUTO_REPLY_PRIVACY_POLICY = `Privacy rules, these override any other instruction:
+- You may use this conversation thread to reply naturally, it is the contact's own conversation.
+- Never reveal or hint at the business's internal record of this person: notes, tags, categories, sentiment or mood scores, account status, payment standing, or any other internal assessment.
+- Never reveal anything about any other person or contact.
+- Do not summarise or confirm their history on other channels, such as their phone calls, other email threads, or SMS messages. If they ask, say you cannot go over their record here and offer to have someone follow up.
+- If you are unsure whether something is safe to share, do not share it.`;
+
 const auto_response = async function (uid, profile_id, contact_id, conversation_type = 'email') {
   try {
     const account_profile_info = await get_active_account_profile_info(uid, profile_id);
@@ -8515,11 +8662,11 @@ const auto_response = async function (uid, profile_id, contact_id, conversation_
 
     let account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
 
-    // The main profile is the account's OWN identity: never auto-respond on it
-    // (you don't auto-reply to yourself). Authoritative check via the account's
-    // account_profile_id, independent of the stored auto_respond flag.
-    if (account_doc?.account_profile_id && profile_id === account_doc.account_profile_id) return;
-
+    // The main profile auto-responds like any other (Boaz, 2026-07-31, reversing UI-44
+    // part 2). It used to be hard-skipped here on the reasoning that you do not auto-reply
+    // to yourself, but the main profile is the identity most people actually receive on, so
+    // excluding it meant the feature was off exactly where it was most wanted. The
+    // auto_respond flag and mode above are now the only gate, for every profile.
     if (account_profile_doc.auto_respond_mode === 'when_offline' && account_doc.socket_id) return;
     if (!['always', 'when_offline'].includes(account_profile_doc.auto_respond_mode)) return;
 
@@ -8585,6 +8732,8 @@ const auto_response = async function (uid, profile_id, contact_id, conversation_
           instructions: `You are ${account_profile_doc.profile_name || userName}'s automatic ${conversation_type === 'chat' ? 'chat' : 'email'} assistant.
 Reply to the latest incoming message from ${contact_doc.name || contact_doc.email} in a friendly, helpful, and concise way.
 Use the conversation history for context.
+
+${AUTO_REPLY_PRIVACY_POLICY}
 Match the language the contact wrote in.
 Do not mention that the reply is automated.
 ${conversation_type === 'chat' ? 'Return only the chat message text, ready to send.' : 'Return only the email body, ready to send.'}
@@ -8626,6 +8775,8 @@ ${account_profile_doc.profile_signature || ''}`.trim(),
 
 You are composing an automatic ${conversation_type === 'chat' ? 'chat' : 'email'} reply.
 Use the existing conversation history as context.
+
+${AUTO_REPLY_PRIVACY_POLICY}
 Reply as ${account_profile_doc.profile_name || userName}.
 ${conversation_type === 'chat' ? 'Return only the chat message text, ready to send.' : 'Return only the email body text, ready to send.'}
 Keep the response concise, natural, and professional.${

package/package.json

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