@xuda.io/ai_module 1.1.5651 → 1.1.5652

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
@@ -4763,7 +4819,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 +4828,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 +4848,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 +5093,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 +5248,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 +5308,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 +5459,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 +6521,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,
     });
@@ -6474,6 +6566,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);
@@ -6566,6 +6661,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 +6680,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');
       }

package/package.json

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