@xuda.io/ai_module 1.1.5652 → 1.1.5653

package/index.mjs

@@ -426,6 +426,53 @@ const account_msa = await import(`${module_path}/account_module/index_msa.mjs`);
 const drive_msa = await import(`${module_path}/drive_module/index_msa.mjs`);
 const misc_msa = await import(`${module_path}/misc_module/index_msa.mjs`);
 
+// Did the user press Stop on this run?
+//
+// abort_job stamps `abort: true` on the job doc and nothing else. The doc only
+// flips to stat 4 when the worker calls update_job and that call sees the flag,
+// and a chat run never calls update_job: it reports progress over the websocket
+// (emitToDashboard), not through the job. So every poll here used to watch a
+// stat that could not change, and Stop did nothing but leave the response
+// streaming. Read the flag itself, and keep the stat + "job vanished" cases so
+// non-chat runs (which do go through update_job) behave exactly as before.
+const is_job_aborted = async function (job_id) {
+  if (!job_id) return false;
+  try {
+    const job_info = await jobs_ms.get_job_info({ job_id });
+    return job_info.code < 0 || job_info?.data?.abort === true || job_info?.data?.stat === 4;
+  } catch (err) {
+    return false;
+  }
+};
+
+// Watch for Stop for as long as a response stream is open, and cut the stream when it comes.
+//
+// The per-chunk check inside the read loop only runs when a chunk actually arrives, and a
+// reasoning model can sit silent for twenty seconds before its first token. That silence is
+// exactly when the user reaches for Stop, and the loop is parked on `await` the whole time, so
+// the run stayed unstoppable until it started talking (measured: 26s from Stop to stop).
+// Destroying the reader makes the parked for-await throw, which lands in the same abort path
+// the per-chunk check uses. Returns the function that cancels the watch.
+const watch_job_abort = function (job_id, output_stream) {
+  if (!job_id || !output_stream) return () => {};
+  let checking = false;
+  const timer = setInterval(async () => {
+    if (checking) return;
+    checking = true;
+    try {
+      if (await is_job_aborted(job_id)) {
+        clearInterval(timer);
+        try {
+          output_stream.destroy?.(new Error('aborted'));
+        } catch (err) {}
+      }
+    } finally {
+      checking = false;
+    }
+  }, 500);
+  return () => clearInterval(timer);
+};
+
 var open_ai_status = {};
 const report_ai_status = function (model, err) {
   open_ai_status[model] = { stat: err ? 'error' : 'ok', date: new Date(), err };
@@ -1521,6 +1568,41 @@ const chat_finished_summary = function (text) {
   return plain.length > 160 ? `${plain.slice(0, 157)}...` : plain;
 };
 
+// The alert should look like the chat it came from, so it carries that chat's own
+// picture: the agent's image, the generated chat thumbnail, or the contact's avatar,
+// the same one the chat card shows. Returns undefined when the chat has no picture yet,
+// and notification_module then falls back to the app icon as before. Never throws: an
+// alert without a picture is still an alert.
+const chat_finished_image = async function (uid, conversation_doc) {
+  try {
+    const studio_meta = conversation_doc?.studio_meta;
+    const agent_image = studio_meta?.agent_image?.[0]?.file_url || studio_meta?.agent_marketplace_image?.[0]?.file_url;
+    if (agent_image) return agent_image;
+
+    // Same field the chat card reads, so the alert and the card agree.
+    const chat_image = conversation_doc?.chat_image?.[0]?.file_url;
+    if (chat_image) return chat_image;
+
+    const reference_type = conversation_doc?.reference_type;
+    const reference_id = conversation_doc?.reference_id;
+    if (!reference_id) return undefined;
+
+    if (reference_type === 'contacts') {
+      const contact = await get_contact_info(uid, null, reference_id);
+      return contact?.profile_picture || contact?.profile_avatar || undefined;
+    }
+
+    if (reference_type === 'ai_agents') {
+      const account_profile_info = await get_active_account_profile_info(uid);
+      const agent_doc = await load_ai_agent_doc(account_profile_info?.app_id, reference_id);
+      return agent_doc?.studio_meta?.agent_image?.[0]?.file_url || agent_doc?.agent_image?.[0]?.file_url || undefined;
+    }
+  } catch (err) {
+    console.error(`[chat_finished_image] ${err?.message || err}`);
+  }
+  return undefined;
+};
+
 // Some flows can reach a second terminal event in one turn (a stream that completed and
 // then failed while its result was being persisted), and each one closes the stream. The
 // user only wants to be told once per chat, so keep the last alert per conversation and
@@ -1547,6 +1629,7 @@ const notify_chat_finished = async function ({ uid, conversation_id, conversatio
     if (!presence || presence.code < 0 || presence.data !== false) return;
 
     const title = String(conversation_doc?.title || '').trim();
+    const image = await chat_finished_image(uid, conversation_doc);
 
     // Stamped only now that an alert is really going out. Stamping every finished run
     // would let a run nobody needed to hear about (the user was watching it) silence the
@@ -1563,6 +1646,8 @@ const notify_chat_finished = async function ({ uid, conversation_id, conversatio
       uid_arr: [uid],
       subject: title ? `Ready: ${title}` : 'Your chat is ready',
       body: chat_finished_summary(text),
+      // The chat's own picture, on the push and on the toast that stands in for it.
+      ...(image ? { icon: image } : {}),
       delivery_method: ['push'],
       display_type: 'info',
       ref: conversation_id,
@@ -6558,7 +6643,14 @@ Rules:
 };
 
 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 { profile_id, uid, email_id, perform_ai_execution = true, from_mailbox, _thread_reentry } = req;
+  // A send a person made in the app is outbound by definition. Only the mailbox path can
+  // produce an inbound item and it always says which way the mail went (email_module reads
+  // it off is_sent), so an absent direction here means a user-invoked send: the composer,
+  // or any future caller that forgets. It used to be written through as undefined, which
+  // left the key off the saved item entirely and made a mail we sent indistinguishable
+  // from one we received, on the timeline and in the AI's own reading of the thread.
+  const direction = req.direction || 'out';
   const account_profile_info = await get_active_account_profile_info(uid, profile_id);
   let { prompt: body, conversation_doc, attachments = [], ai_agents } = req;
   // UI-126 (b): a composed send arrives already written and already reviewed by the user, so
@@ -6577,9 +6669,26 @@ const chat_email = async function (req, job_id, headers) {
     const conversation_id = conversation_doc._id;
     const sender_app_id = account_profile_info.app_id;
 
-    let email_account_doc = await db_module.get_app_couch_doc_native(sender_app_id, account_profile_info.account_profile_obj?.email_account_id);
+    // UI-161: both of these used to fail as a bare CouchDB `{ message: 'missing' }` with no
+    // clue which id or which database was involved, and the job died there, so an email was
+    // never sent and nothing on screen said why. Each lookup now names what it could not
+    // find. Boaz: "i sent test email to B / it hung".
+    const email_account_id = account_profile_info.account_profile_obj?.email_account_id;
+    let email_account_doc;
+    try {
+      email_account_doc = await db_module.get_app_couch_doc_native(sender_app_id, email_account_id);
+    } catch (err) {
+      console.error(`[chat_email] mailbox doc not found: app_id=${sender_app_id} email_account_id=${email_account_id} profile=${account_profile_info.account_profile_obj?._id}`, err?.message || err);
+      throw new Error(`The mailbox attached to this profile could not be loaded (${email_account_id}). Open Email, go to Profiles, and re-attach it.`);
+    }
 
-    let sender_conversation_doc = await db_module.get_app_couch_doc_native(sender_app_id, conversation_id);
+    let sender_conversation_doc;
+    try {
+      sender_conversation_doc = await db_module.get_app_couch_doc_native(sender_app_id, conversation_id);
+    } catch (err) {
+      console.error(`[chat_email] conversation doc not found: app_id=${sender_app_id} conversation_id=${conversation_id}`, err?.message || err);
+      throw new Error(`This conversation could not be loaded (${conversation_id}).`);
+    }
 
     if (sender_conversation_doc.reference_type !== 'contacts') {
       throw new Error('not an contact conversation');
@@ -6750,6 +6859,17 @@ const chat_email = async function (req, job_id, headers) {
 
     return save_ret;
   } catch (err) {
+    // UI-161: this used to swallow the reason, so a send that died anywhere in here surfaced
+    // as a bare CouchDB `{ message: 'missing' }` on stderr with nothing tying it to a
+    // conversation, a contact or a mailbox. The job then ended and no email went out.
+    console.error(`[chat_email] failed: conversation_id=${conversation_doc?._id} contact=${conversation_doc?.reference_id} app_id=${account_profile_info?.app_id} profile=${account_profile_info?.account_profile_obj?._id} mailbox=${account_profile_info?.account_profile_obj?.email_account_id}`, err?.stack || err?.message || err);
+    // UI-161: an expired or revoked OAuth grant is the single most common way sending stops
+    // working, and "Failed to obtain valid access token" tells the person reading it nothing
+    // about what to do. Name the mailbox and the fix.
+    if (/access token|invalid_grant|unauthorized|invalid credentials/i.test(String(err?.message || ''))) {
+      const mailbox_address = email_account_doc?.email || account_profile_info?.account_profile_obj?.email_account_id || 'this mailbox';
+      return { code: -15, data: `Xuda can no longer sign in to ${mailbox_address}, so the email was not sent. Open Email, go to Mailboxes, and reconnect the account.` };
+    }
     return { code: -15, data: err.message };
   }
 };
@@ -7009,11 +7129,8 @@ ${conversation_history || `User (studio): ${prompt}`}
 
         thinking_index += 1;
         try {
-          if (job_id) {
-            const job_info = await jobs_ms.get_job_info({ job_id });
-            if (job_info.code < 0 || job_info.data.stat === 4) {
-              return;
-            }
+          if (await is_job_aborted(job_id)) {
+            return;
           }
         } catch (error) {}
 
@@ -8055,15 +8172,22 @@ Available CPI methods: ${cpi_tools_ret.selected_methods.join(', ')}${dashboard_s
     if (stream) {
       const output_stream = output.toTextStream({ compatibleWithNodeStreams: true });
       let response_started = false;
-      for await (const chunk of output_stream) {
-        if (!response_started) {
-          response_started = true;
-          emitToDashboard('stream_phase', 'Streaming results', { update: true });
-          emitToDashboard('response_start');
+      // Same Stop watch the contact/agent chat runs. Without it the dashboard chat streamed
+      // to the end no matter what the user pressed.
+      const stop_abort_watch = watch_job_abort(job_id, output_stream);
+      try {
+        for await (const chunk of output_stream) {
+          if (!response_started) {
+            response_started = true;
+            emitToDashboard('stream_phase', 'Streaming results', { update: true });
+            emitToDashboard('response_start');
+          }
+          const text = chunk.toString();
+          response_text += text;
+          emitToDashboard('stream_delta', text);
         }
-        const text = chunk.toString();
-        response_text += text;
-        emitToDashboard('stream_delta', text);
+      } finally {
+        stop_abort_watch();
       }
     }
 
@@ -8107,6 +8231,26 @@ Available CPI methods: ${cpi_tools_ret.selected_methods.join(', ')}${dashboard_s
       } catch (e) {}
       return { code: -1, data: { error: 'credit_limit', account_id: err.account_id } };
     }
+    // The user pressed Stop. That is not a failure: say so plainly, flag the stream
+    // end as aborted (the chat-finished alert reads that flag to stay quiet) and skip
+    // the error card and the error log.
+    if ((typeof err === 'string' ? err : err?.message) === 'aborted') {
+      emitToDashboard('stream_phase', 'Stopped', { update: true });
+      emitToDashboard('response_start');
+      streamText('Stopped.');
+      emitToDashboard('stream_end', undefined, { aborted: true });
+
+      try {
+        conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_id);
+        conversation_doc.ts = Date.now();
+        conversation_doc.stat = 3;
+        conversation_doc.process_stat = 'partial';
+        await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+      } catch (e) {}
+
+      return { code: -4, data: 'aborted' };
+    }
+
     const error_message = get_error_message(err, 'dashboard request failed');
     // Never echo the raw error to the client — it can leak provider/quota/host
     // details (e.g. the OpenAI 429 quota text). Log it; show a clean card via the
@@ -9100,7 +9244,7 @@ const ai_chat_conversation = async function (req, job_id, headers) {
         let interval = setInterval(async function () {
           const job_info = await jobs_ms.get_job_info({ job_id });
 
-          if (job_info.code < 0 || job_info.data.stat === 4) {
+          if (job_info.code < 0 || job_info?.data?.abort === true || job_info.data.stat === 4) {
             clearInterval(interval);
             resolve({ code: -1, data: 'aborted' });
             return;
@@ -9372,7 +9516,7 @@ const ai_chat_conversation = async function (req, job_id, headers) {
             clearInterval(interval);
             resolve(null);
           } else {
-            if (job_info.code < 0 || job_info.data.stat === 4) {
+            if (job_info.code < 0 || job_info?.data?.abort === true || job_info.data.stat === 4) {
               reject('aborted');
               clearInterval(interval);
               return;
@@ -9396,9 +9540,7 @@ const ai_chat_conversation = async function (req, job_id, headers) {
     const run_agent = function (_agent, prompt, opt) {
       return new Promise(async (resolve, reject) => {
         let interval = setInterval(async function () {
-          const job_info = await jobs_ms.get_job_info({ job_id });
-
-          if (job_info.code < 0 || job_info.data.stat === 4) {
+          if (await is_job_aborted(job_id)) {
             reject(new Error('aborted'));
             clearInterval(interval);
           }
@@ -9581,29 +9723,28 @@ const ai_chat_conversation = async function (req, job_id, headers) {
 
       // 1. Consume the stream exactly once
       let string_debug = '';
-      let chunks = 0;
-      for await (const chunk of output_stream) {
-        // console.log(chunks);
-        if (chunks % 10 === 0) {
-          const job_info = await jobs_ms.get_job_info({ job_id });
-          if (job_info.code < 0 || job_info.data.stat === 4) {
-            throw 'aborted';
-          }
-        }
-        chunks++;
-        if (!response_start) {
-          response_start = true;
+      // Stop is watched on its own timer rather than per chunk: a chunk-counted check is
+      // blind while the model is thinking, and it put a broker round trip in the middle of
+      // the stream. The watch cuts the reader, which throws into the abort path below.
+      const stop_abort_watch = watch_job_abort(job_id, output_stream);
+      try {
+        for await (const chunk of output_stream) {
+          if (!response_start) {
+            response_start = true;
 
-          // await update_job('streaming results');
-          emitToDashboard('stream_phase', 'Streaming results');
-          emitToDashboard('response_start');
+            // await update_job('streaming results');
+            emitToDashboard('stream_phase', 'Streaming results');
+            emitToDashboard('response_start');
+          }
+          const text = chunk.toString();
+          // console.log('[CHUNK]', text);
+          emitToDashboard('stream_delta', text);
+          string_debug += text;
+          // Accumulate it
+          buffer += chunk;
         }
-        const text = chunk.toString();
-        // console.log('[CHUNK]', text);
-        emitToDashboard('stream_delta', text);
-        string_debug += text;
-        // Accumulate it
-        buffer += chunk;
+      } finally {
+        stop_abort_watch();
       }
       // console.log('string_debug', string_debug);
       emitToDashboard('stream_end');
@@ -9641,7 +9782,11 @@ const ai_chat_conversation = async function (req, job_id, headers) {
     emitToDashboard(
       'stream_delta',
       aborted
-        ? 'Stopped.'
+        ? // Mid-answer, this delta lands straight onto the last word the model wrote
+          // ("...movable typeStopped."), so break the line first.
+          response_started
+          ? '\n\nStopped.'
+          : 'Stopped.'
         : reason === 'agent_unavailable'
           ? "This agent isn't available right now. Please try again in a moment."
           : "I couldn't complete that just now. Please try again in a moment.",

package/package.json

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