@xuda.io/ai_module 1.1.5651 → 1.1.5653

package/index.mjs

@@ -231,6 +231,62 @@ const resolve_ai_model = function (m) {
   return _conf?.ai_models?.[code]?.model || _conf?.ai_models?.[m]?.model || m;
 };
 
+// Every text model in the catalog is a gpt-5-family REASONING model, and the API
+// default effort is 'medium'. Measured on dev 2026-08-11: gpt-5-nano asked to write
+// a three line email burned 960-1600 hidden reasoning tokens and took 10-16s, while
+// the same call at effort 'minimal' took 1.4-2.7s with 0 reasoning tokens and the
+// same answer. The cheapest model was the SLOWEST thing we ran, purely because
+// nobody set an effort. So every internal call now names one.
+//
+// 'minimal' is the right default for what submit_chat_gpt_prompt is actually used
+// for (titles, categories, field assist, short classifications). A caller that
+// genuinely needs the model to think passes effort: 'low' | 'medium' | 'high'.
+//
+// Non-reasoning ids (gpt-4o-mini and friends, still named by a few modules) reject
+// the parameter outright, so only send it to a model that understands it.
+const INTERNAL_AI_EFFORT = () => _conf?.internal_ai_effort || 'minimal';
+
+const _is_reasoning_model = function (real_model) {
+  return /^(gpt-5|o[1-9])/.test(String(real_model || ''));
+};
+
+// Responses-API shape: { reasoning: { effort } }. Returns {} when the model or the
+// caller opted out, so it can always be spread into the request.
+const reasoning_opt = function (real_model, effort) {
+  const e = effort === undefined ? INTERNAL_AI_EFFORT() : effort;
+  if (!e || e === 'default' || !_is_reasoning_model(real_model)) return {};
+  return { reasoning: { effort: e } };
+};
+
+// Request timeout, sized off the effort tier.
+//
+// Measured on dev 2026-08-11: roughly 13% of calls to api.openai.com go silent for
+// 19.5-20s AFTER the edge has ACKed our request, on a 401 to /v1/models as readily
+// as on a real completion, and from the laptop as readily as from dev. tcpdump shows
+// no retransmission in either direction, so it is upstream at OpenAI and nothing here
+// fixes it. See the cf-ray IDs in the change log.
+//
+// What we CAN stop doing is waiting it out. The SDK had no timeout set, so its 10
+// minute default applied and every stall cost the full 20s. A stalled request never
+// recovers early and a fresh one answers in ~200ms, so the cure is to give up and
+// re-ask. The stall lands before generation starts, so the abandoned attempt bills
+// nothing and there is no reason to hedge (leave the first running) instead.
+//
+// Timeouts are ~6x the observed normal for the tier, so only a genuinely stuck call
+// trips them. The SDK's own maxRetries (2) does the re-asking and treats a timeout as
+// retryable, which puts 'minimal' at ~9s instead of ~21s for a stall.
+const AI_EFFORT_TIMEOUT_MS = { minimal: 8000, low: 15000, medium: 60000, high: 120000 };
+const AI_TIMEOUT_DEFAULT_MS = 60000;
+
+const ai_timeout_ms = function (effort, real_model, tools) {
+  // A hosted tool (web_search and friends) runs its own loop inside the one request
+  // and is legitimately slow, so those never get the short tier.
+  if (Array.isArray(tools) && tools.length) return _conf.ai_tools_timeout_ms || 180000;
+  if (!_is_reasoning_model(real_model)) return _conf.ai_timeout_ms?.default || AI_TIMEOUT_DEFAULT_MS;
+  const e = effort === undefined ? INTERNAL_AI_EFFORT() : effort;
+  return _conf.ai_timeout_ms?.[e] || AI_EFFORT_TIMEOUT_MS[e] || _conf.ai_timeout_ms?.default || AI_TIMEOUT_DEFAULT_MS;
+};
+
 // A catalog code a user may pick for Codex generation: an OpenAI text model
 // flagged codex:true in ai_models. Guards generate_site_draft's model param so a
 // non-codex pick (image/voice/unknown) falls back to the default rather than
@@ -370,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 };
@@ -1465,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
@@ -1491,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
@@ -1507,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,
@@ -4763,7 +4904,7 @@ export const delete_prompt_attachment = async function (req, job_id, headers, fi
 };
 
 export const submit_chat_gpt_prompt = async function (req) {
-  const { model = _conf.default_ai_model, prompt = '', response_format, uid, metadata = {}, account_profile_info, tools = [], conversation_id, response_id } = req; //'gpt-5-mini
+  const { model = _conf.default_ai_model, prompt = '', response_format, uid, metadata = {}, account_profile_info, tools = [], conversation_id, response_id, effort } = req; //'gpt-5-mini
 
   let formattedParams;
   if (response_format) {
@@ -4772,14 +4913,19 @@ export const submit_chat_gpt_prompt = async function (req) {
 
   try {
     let response;
+    const real_model = resolve_ai_model(model);
+    const eff = effort === undefined ? INTERNAL_AI_EFFORT() : effort;
+    const timeout = ai_timeout_ms(effort, real_model, tools);
+    const started = Date.now();
     try {
       let opt = {
-        model: resolve_ai_model(model),
+        model: real_model,
         input: prompt,
         tools,
         text: {
           format: formattedParams,
         },
+        ...reasoning_opt(real_model, effort),
       };
       if (conversation_id) {
         opt.conversationId = conversation_id;
@@ -4787,10 +4933,25 @@ export const submit_chat_gpt_prompt = async function (req) {
       if (response_id) {
         opt.previous_response_id = response_id;
       }
-      response = await client.responses.create(opt);
+      // Second argument is per-request options, not part of the body. The SDK's own
+      // maxRetries (2) treats a timeout as retryable, which is the whole point: a
+      // request the OpenAI edge has gone silent on is abandoned and re-asked instead
+      // of waited out.
+      response = await client.responses.create(opt, { timeout });
       report_ai_status(model);
+      // No timing existed on this path, so "the AI is slow" was never anything we
+      // could point at a number. One line per call, only when it actually dragged.
+      const ms = Date.now() - started;
+      if (ms > (_conf.ai_slow_log_ms || 5000)) {
+        console.warn(`[ai] slow prompt ${ms}ms model=${real_model} effort=${eff} timeout=${timeout}ms reasoning_tokens=${response?.usage?.output_tokens_details?.reasoning_tokens ?? '?'} func=${metadata?.func || '-'}`);
+      }
     } catch (err) {
       report_ai_status(model, err);
+      // A timeout here means every attempt was abandoned, so say so plainly rather
+      // than handing the caller the SDK's generic connection-error wording.
+      if (/timed? ?out/i.test(err?.message || '') || err?.name === 'APIConnectionTimeoutError') {
+        console.warn(`[ai] prompt timed out after ${Date.now() - started}ms model=${real_model} effort=${eff} timeout=${timeout}ms func=${metadata?.func || '-'}`);
+      }
       throw err;
     }
     account_msa.record_ai_usage(uid, response.usage.input_tokens, response.usage.output_tokens, 'submit chat', prompt, model, metadata, account_profile_info, tools);
@@ -5017,6 +5178,9 @@ export const ai_field_assist = async function (req) {
     uid,
     prompt: parts.join('\n'),
     model,
+    // Sparkle-icon writing: the user is watching, and the per-field rules above are
+    // explicit enough that hidden reasoning adds latency, not quality.
+    effort: _conf.field_assist?.effort || 'low',
     metadata: { func: 'ai_field_assist', field, mode },
     account_profile_info,
   });
@@ -5169,6 +5333,10 @@ export const triage_error_incident = async function (req) {
     prompt,
     response_format: verdict_schema,
     uid: _conf.superuser_account_ids?.[0],
+    // Root-causing an incident is the one thing here worth thinking about, and it
+    // runs on a cron where nobody is watching a spinner, so it opts out of the
+    // 'minimal' default.
+    effort: _conf.error_resolver?.effort || 'medium',
     metadata: { func: 'triage_error_incident', signature: incident?.signature, code: incident?.code },
   });
 
@@ -5225,6 +5393,8 @@ export const diagnose_vps_snapshot = async function (req) {
     prompt: parts.join('\n'),
     response_format: verdict_schema,
     uid,
+    // Reading a server snapshot is analysis, not a one-liner, and it runs unattended.
+    effort: _conf.auto_diagnose?.effort || 'medium',
     metadata: { func: 'diagnose_vps_snapshot', app_name },
   });
 
@@ -5374,6 +5544,9 @@ export const generate_release_notes = async function (req) {
     uid,
     prompt: parts.join('\n'),
     model: _conf.release_notes?.model || _conf.default_ai_model,
+    // Turning a changelog into readable notes is a writing job, so give it a little
+    // more than 'minimal' without paying for full reasoning.
+    effort: _conf.release_notes?.effort || 'low',
     metadata: { func: 'generate_release_notes', app_id: app_ref, version },
     account_profile_info,
   });
@@ -6433,6 +6606,10 @@ Rules:
       prompt,
       model: ai_model || _conf.default_ai_model,
       response_format: ComposedEmailSchema,
+      // The "Writing your email..." spinner. It carries a long rule list, so it gets
+      // 'low' rather than 'minimal' to keep instruction-following tight; that is still
+      // a few seconds instead of the 10-16s the unset default was costing.
+      effort: _conf.compose_email_effort || 'low',
       metadata: { contact_id, func: 'compose_contact_email' },
       account_profile_info,
     });
@@ -6466,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
@@ -6474,6 +6658,9 @@ const chat_email = async function (req, job_id, headers) {
   // path, and every inbound/auto reply) leaves both empty and behaves exactly as before.
   const composed_subject = String(req.subject || '').trim();
   const composed_html = _sanitize_email_html(req.body_html);
+  // UI-155: the template the user picked in the composer, for THIS message only. Empty on
+  // every other path, which leaves the address's saved default in charge.
+  const composed_style = String(req.template_style || '').trim();
   try {
     if (!account_profile_info.account_profile_obj?.email_account_id) {
       throw await email_binding_error(account_profile_info);
@@ -6482,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');
@@ -6566,6 +6770,9 @@ const chat_email = async function (req, job_id, headers) {
           uid,
           email_account_id: profile_doc.email_account_id,
           style: profile_doc.email_template?.style,
+          // UI-155: a per-message choice made in the composer, which outranks the address's
+          // saved default inside the renderer.
+          ...(composed_style ? { style_override: composed_style } : {}),
           body_text: body,
           // A composed body is already HTML the user laid out (bold, lists, links), so the
           // template has to drop it in as-is. Escaping it into paragraphs the way a plain
@@ -6582,7 +6789,12 @@ const chat_email = async function (req, job_id, headers) {
       // With no template style selected there is nothing wrapping the body, so the composed
       // HTML is the whole message. Without this it would fall through to sendEmailFromAccount's
       // "wrap the plain text in one <p>" default and the formatting would be lost.
-      sent_email_result = await email_ms.sendEmailFromAccount(email_account_doc, contact_info.email, subject, body, template_html || composed_html || null, email_attachments);
+      // UI-157: cc / bcc come from the composer and are normalized inside sendEmailFromAccount,
+      // so anything that is not an address is dropped rather than reaching the SMTP server.
+      sent_email_result = await email_ms.sendEmailFromAccount(email_account_doc, contact_info.email, subject, body, template_html || composed_html || null, email_attachments, {
+        cc: req.cc,
+        bcc: req.bcc,
+      });
       if (!sent_email_result.success) {
         throw new Error('error sending email');
       }
@@ -6647,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 };
   }
 };
@@ -6906,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) {}
 
@@ -7952,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();
       }
     }
 
@@ -8004,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
@@ -8997,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;
@@ -9269,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;
@@ -9293,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);
           }
@@ -9478,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');
@@ -9538,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.5651",
+  "version": "1.1.5653",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",