@xuda.io/ai_module 1.1.5595 → 1.1.5597

package/index.mjs

@@ -1490,6 +1490,9 @@ export const get_chat_conversation = async function (req) {
 
     for (let conversation_item_doc of conversation_items.docs || []) {
       conversation_item_doc.metadata = conversation_item_doc.metadata || {};
+      if (conversation_item_doc.plan_mode && typeof conversation_item_doc.plan_accepted === 'undefined') {
+        conversation_item_doc.plan_accepted = false;
+      }
       if (!conversation_item_doc.read) {
         conversation_item_doc.read = {};
       }
@@ -4299,15 +4302,30 @@ const contactGuardrailAgent = new Agent({
 // };
 
 export const submit_chat_conversation = async function (req, job_id, headers) {
-  const { profile_id, uid, metadata = {} } = req;
+  const { profile_id, uid, metadata = {}, accepted_plan_item_id } = req;
   let { conversation_id } = req;
   try {
     if (!conversation_id) throw new Error('missing conversation_id');
     const account_profile_info = await get_active_account_profile_info(uid, profile_id);
 
     let conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_id);
-    const normalized_plan_mode = normalize_boolean(req.plan_mode ?? conversation_doc.plan_mode);
-    const route_to_studio = conversation_doc.conversation_type === 'studio' || req.conversation_type === 'studio' || normalized_plan_mode;
+    let accepted_plan_item;
+    if (accepted_plan_item_id) {
+      accepted_plan_item = await db_module.get_app_couch_doc_native(account_profile_info.app_id, accepted_plan_item_id);
+      if (accepted_plan_item.docType !== 'chat_conversation_item') throw new Error('accepted plan item must be a chat_conversation_item');
+      if (accepted_plan_item.conversation_id !== conversation_id) throw new Error('accepted plan item does not belong to this conversation');
+      if (!normalize_boolean(accepted_plan_item.plan_mode)) throw new Error('accepted plan item is not a plan-mode item');
+
+      if (!accepted_plan_item.plan_accepted) {
+        accepted_plan_item.plan_accepted = true;
+        accepted_plan_item.plan_accepted_at = Date.now();
+        accepted_plan_item.plan_accepted_by_uid = uid;
+        await db_module.save_app_couch_doc_native(account_profile_info.app_id, accepted_plan_item);
+      }
+    }
+
+    const normalized_plan_mode = accepted_plan_item_id ? false : normalize_boolean(req.plan_mode ?? conversation_doc.plan_mode);
+    const route_to_studio = conversation_doc.conversation_type === 'studio' || req.conversation_type === 'studio' || normalized_plan_mode || Boolean(accepted_plan_item_id);
 
     if (route_to_studio && conversation_doc.conversation_type !== 'studio') {
       conversation_doc.conversation_type = 'studio';
@@ -4317,71 +4335,76 @@ export const submit_chat_conversation = async function (req, job_id, headers) {
 
     req.plan_mode = normalized_plan_mode;
     req.conversation_doc = conversation_doc;
+    req.accepted_plan_item = accepted_plan_item;
     req.metadata = metadata || {};
     let ret;
 
-    switch (conversation_doc.reference_type) {
-      case 'contacts': {
-        req._thread_reentry = Date.now() - conversation_doc.date_created_ts > 60000;
+    if (route_to_studio) {
+      ret = await chat_studio(req, job_id, headers);
+    } else {
+      switch (conversation_doc.reference_type) {
+        case 'contacts': {
+          req._thread_reentry = Date.now() - conversation_doc.date_created_ts > 60000;
 
-        account_msa.ts_contact(uid, conversation_doc.reference_id);
+          account_msa.ts_contact(uid, conversation_doc.reference_id);
 
-        switch (conversation_doc.conversation_type) {
-          case 'note': {
-            ret = await chat_note(req, job_id, headers);
-            break;
-          }
-          case 'ai_chat': {
-            ret = await ai_chat_conversation(req, job_id, headers);
-            break;
-          }
+          switch (conversation_doc.conversation_type) {
+            case 'note': {
+              ret = await chat_note(req, job_id, headers);
+              break;
+            }
+            case 'ai_chat': {
+              ret = await ai_chat_conversation(req, job_id, headers);
+              break;
+            }
 
-          case 'email': {
-            ret = await chat_email(req, job_id, headers);
-            break;
-          }
+            case 'email': {
+              ret = await chat_email(req, job_id, headers);
+              break;
+            }
 
-          case 'chat': {
-            ret = await contact_chat_conversation(req, job_id, headers);
-            break;
+            case 'chat': {
+              ret = await contact_chat_conversation(req, job_id, headers);
+              break;
+            }
+
+            default:
+              ret = { code: -44, data: 'invalid conversation_type ' + conversation_doc.conversation_type };
+              break;
           }
 
-          default:
-            ret = { code: -44, data: 'invalid conversation_type ' + conversation_doc.conversation_type };
-            break;
+          break;
         }
 
-        break;
-      }
+        case 'ai_chats': {
+          ret = await ai_chat_conversation(req, job_id, headers);
+          break;
+        }
 
-      case 'ai_chats': {
-        ret = await ai_chat_conversation(req, job_id, headers);
-        break;
-      }
+        case 'apps': {
+          ret = await chat_studio(req, job_id, headers);
+          break;
+        }
 
-      case 'apps': {
-        ret = await chat_studio(req, job_id, headers);
-        break;
-      }
+        case 'ai_agent': {
+          ret = await ai_chat_conversation(req, job_id, headers);
+          break;
+        }
 
-      case 'ai_agent': {
-        ret = await ai_chat_conversation(req, job_id, headers);
-        break;
-      }
+        case 'studio': {
+          ret = await chat_studio(req, job_id, headers);
+          break;
+        }
 
-      case 'studio': {
-        ret = await chat_studio(req, job_id, headers);
-        break;
-      }
+        case 'dashboard': {
+          ret = await dashboard_chat(req, job_id, headers);
+          break;
+        }
 
-      case 'dashboard': {
-        // ??
-        break;
+        default:
+          ret = await ai_chat_conversation(req, job_id, headers);
+          break;
       }
-
-      default:
-        ret = await ai_chat_conversation(req, job_id, headers);
-        break;
     }
 
     // if (route_to_studio) {
@@ -4704,7 +4727,7 @@ const chat_email = async function (req, job_id, headers) {
 const chat_studio = async function (req, job_id, headers) {
   const { uid, profile_id } = req;
   const account_profile_info = await get_active_account_profile_info(uid, profile_id);
-  let { prompt, conversation_doc, attachments = [], plan_mode = false, stream = true } = req;
+  let { prompt, conversation_doc, attachments = [], plan_mode = false, stream = true, accepted_plan_item_id, accepted_plan_item } = req;
 
   const conversation_id = conversation_doc._id;
   const normalized_plan_mode = normalize_boolean(plan_mode);
@@ -4800,6 +4823,8 @@ const chat_studio = async function (req, job_id, headers) {
 
     const items = (ret.docs || []).reverse().filter((item) => item.text || item.prompt || item?.file?.filename);
     const conversation_history = items.map(formatConversationHistoryItem).join('\n\n');
+    const accepted_plan_text = accepted_plan_item_id ? (accepted_plan_item?.studio_result || accepted_plan_item?.text || accepted_plan_item?.prompt || '').toString().trim() : '';
+    const accepted_plan_context = accepted_plan_text ? `\nThe user has accepted the following plan. Execute it end-to-end:\n\n${accepted_plan_text}\n` : '';
 
     return `You are working inside Xuda Studio.
 
@@ -4807,6 +4832,7 @@ Use the conversation history below as the main source of context for the current
 The last user message is the latest request that should be handled now.
 When plan_mode is true, create a plan only and do not save studio docs.
 When plan_mode is false, generate the studio docs and save them into the project.
+${accepted_plan_context}
 
 Conversation history:
 ${conversation_history || `User (studio): ${prompt}`}
@@ -4914,6 +4940,7 @@ ${conversation_history || `User (studio): ${prompt}`}
       rtl: _common.detectRTL(prompt),
       job_id,
       plan_mode: normalized_plan_mode,
+      plan_accepted: false,
       studio_method: plugin_method,
       target_app_id,
     };
@@ -5031,6 +5058,7 @@ ${conversation_history || `User (studio): ${prompt}`}
       rtl: _common.detectRTL(response_text),
       job_id,
       plan_mode: normalized_plan_mode,
+      plan_accepted: false,
       studio_method: plugin_method,
       studio_result,
       target_app_id,
@@ -5058,6 +5086,408 @@ ${conversation_history || `User (studio): ${prompt}`}
   }
 };
 
+const get_dashboard_chat_context = function (req, conversation_doc) {
+  return (req.context || req.dashboard_context || req.metadata?.context || conversation_doc.context || conversation_doc.dashboard_context || conversation_doc.metadata?.context || '').toString().trim().toLowerCase();
+};
+
+const get_dashboard_cpi_keywords = function (context, prompt = '') {
+  const haystack = `${context || ''} ${prompt || ''}`.toLowerCase();
+  const keyword_sets = {
+    data: ['data', 'database', 'db', 'dbs', 'table', 'tables', 'couch', 'read', 'create', 'update', 'delete', 'restore', 'count'],
+    account: ['account', 'profile', 'profiles', 'user', 'users', 'contact', 'contacts', 'member', 'members', 'share', 'team'],
+    apps: ['app', 'apps', 'project', 'projects', 'config', 'backup', 'release', 'notification', 'studio', 'mini'],
+    deploy: ['deploy', 'deployment', 'instance', 'server', 'region', 'domain', 'dns', 'traffic', 'firewall', 'usage', 'build'],
+    drive: ['drive', 'file', 'files', 'folder', 'upload', 'extract', 'rename', 'workspace'],
+    plugins: ['plugin', 'plugins', 'install', 'uninstall', 'category', 'categories'],
+    email: ['email', 'mailbox', 'mailboxes', 'mail'],
+    logs: ['log', 'logs', 'security', 'session', 'traffic'],
+    ai: ['ai', 'chat', 'agent', 'workspace', 'conversation'],
+  };
+
+  for (const [key, keywords] of Object.entries(keyword_sets)) {
+    if (haystack.includes(key) || keywords.some((keyword) => haystack.includes(keyword))) {
+      return keywords;
+    }
+  }
+
+  return [];
+};
+
+const get_dashboard_cpi_zod_item = function (key, val = {}) {
+  let schema;
+
+  if (val.enum?.length) {
+    schema = z.enum(val.enum);
+  } else {
+    switch (val.type) {
+      case 'string':
+        schema = z.string();
+        break;
+      case 'number':
+      case 'integer':
+        schema = z.number();
+        if (val.type === 'integer') schema = schema.int();
+        break;
+      case 'boolean':
+        schema = z.boolean();
+        break;
+      case 'array':
+        schema = z.array(get_dashboard_cpi_zod_item('', val.items || { type: 'any' }));
+        break;
+      case 'object': {
+        const props = {};
+        const fields = val.items?.properties || val.properties || {};
+        const required = val.items?.required || val.required || [];
+        for (const [item_key, item_val] of Object.entries(fields)) {
+          props[item_key] = get_dashboard_cpi_zod_item(item_key, item_val);
+          if (!required.includes(item_key)) {
+            props[item_key] = props[item_key].optional();
+          }
+        }
+        schema = z.object(props);
+        break;
+      }
+      default:
+        schema = z.any();
+        break;
+    }
+  }
+
+  if (!val.mandatory) {
+    schema = schema.optional();
+  }
+
+  const valid_values = val.options?.length ? ` Valid values: ${val.options.join(', ')}.` : '';
+  const desc = val.description ? `${val.name || key.replace(/_/g, ' ')} - ${val.description}${valid_values}` : valid_values;
+  return desc ? schema.describe(desc) : schema;
+};
+
+const get_dashboard_cpi_tools = function ({ uid, profile_id, gtp_token, app_id, context, prompt }) {
+  const keywords = get_dashboard_cpi_keywords(context, prompt);
+  const tools = [];
+  const selected_methods = [];
+  const method_entries = [];
+
+  for (const [method_name, method_prop] of Object.entries(_conf.cpi_methods || {})) {
+    if (!method_prop) continue;
+    if (method_prop.private) continue;
+    if (!method_prop.description && !method_prop.tooltip) continue;
+
+    const method_text = `${method_name} ${method_prop.name || ''} ${method_prop.description || ''} ${method_prop.tooltip || ''} ${method_prop.microservice || ''}`.toLowerCase();
+    if (keywords.length && !keywords.some((keyword) => method_text.includes(keyword))) continue;
+
+    method_entries.push({ method_name, method_prop, score: method_prop.mcp ? 2 : 1 });
+  }
+
+  method_entries.sort((a, b) => b.score - a.score || a.method_name.localeCompare(b.method_name));
+
+  for (const { method_name, method_prop } of method_entries.slice(0, 96)) {
+    const inputSchema = {};
+    for (const [field_key, field_val] of Object.entries(method_prop.fields || {})) {
+      inputSchema[field_key] = get_dashboard_cpi_zod_item(field_key, field_val);
+    }
+
+    selected_methods.push(method_name);
+    tools.push(
+      tool({
+        name: method_name.substring(0, 60),
+        description: method_prop.description || method_prop.tooltip || method_name,
+        parameters: z.object(inputSchema),
+        async execute(params) {
+          try {
+            const response = await fetch(`http://localhost:3007/cpi/${method_name}`, {
+              method: 'POST',
+              headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({
+                ...params,
+                uid,
+                profile_id,
+                app_id,
+                reference_id: app_id,
+                gtp_token,
+              }),
+            });
+            const ret = await response.json();
+            return JSON.stringify(ret || '', null, 2);
+          } catch (err) {
+            return `CPI method ${method_name} failed: ${err.message}`;
+          }
+        },
+      }),
+    );
+  }
+
+  return { tools, selected_methods };
+};
+
+const dashboard_chat = async function (req, job_id, headers) {
+  const { uid, profile_id, gtp_token } = req;
+  const account_profile_info = await get_active_account_profile_info(uid, profile_id);
+  let { prompt, conversation_doc, attachments = [], stream = true, ai_model = _conf.default_ai_model, metadata = {} } = req;
+
+  const conversation_id = conversation_doc._id;
+  const dashboard_context = get_dashboard_chat_context(req, conversation_doc);
+  const target_app_id = (await _common.get_project_app_id(req.app_id || conversation_doc.reference_id || account_profile_info.app_id, true)) || account_profile_info.app_id;
+  const prompt_conversation_item_id = await _common.xuda_get_uuid('chat_conversation_item');
+  const response_conversation_item_id = await _common.xuda_get_uuid('chat_conversation_item');
+  const request_started_at = Date.now();
+
+  let stream_delta_seq = 0;
+  let stream_delta_text = '';
+  const emitToDashboard = (type, content, params) => {
+    const is_stream_delta = type === 'stream_delta';
+    const is_stream_end = type === 'stream_end';
+    const seq = is_stream_delta ? ++stream_delta_seq : undefined;
+    if (is_stream_delta) {
+      stream_delta_text += content || '';
+    }
+    ws_dashboard_msa.emit_message_to_dashboard({
+      service: type,
+      to: uid,
+      data: {
+        conversation_id,
+        job_id,
+        delta: content,
+        ...(type === 'stream_start' ? { request_started_at } : {}),
+        ...(seq ? { seq } : {}),
+        ...(is_stream_end
+          ? {
+              stream_id: response_conversation_item_id,
+              final_seq: stream_delta_seq,
+              text: stream_delta_text,
+            }
+          : {}),
+        prompt_conversation_item_id,
+        response_conversation_item_id,
+        params,
+      },
+    });
+  };
+
+  const streamText = function (text, chunk_size = 280) {
+    if (!stream || !text) return;
+    for (let i = 0; i < text.length; i += chunk_size) {
+      emitToDashboard('stream_delta', text.slice(i, i + chunk_size));
+    }
+  };
+
+  const saveUserItem = async function () {
+    const conversation_item_reference_id = await add_conversation_item(uid, profile_id, conversation_id, prompt, 'dashboard', conversation_doc.reference_id, { context: dashboard_context, target_app_id });
+    const out_conversation_item_obj = {
+      _id: prompt_conversation_item_id,
+      stat: 3,
+      docType: 'chat_conversation_item',
+      uid,
+      conversation_type: 'dashboard',
+      type: 'dashboard',
+      date_created_ts: Date.now(),
+      ts: Date.now(),
+      conversation_id,
+      text: prompt,
+      reference_id: conversation_doc.reference_id,
+      conversation_item_reference_id,
+      direction: 'out',
+      role: 'user',
+      read: { [uid]: Date.now() },
+      rtl: _common.detectRTL(prompt),
+      job_id,
+      context: dashboard_context,
+      target_app_id,
+      metadata,
+    };
+
+    const save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, out_conversation_item_obj);
+    if (save_ret.code < 0) throw new Error(save_ret.data);
+    return save_ret;
+  };
+
+  const saveAssistantItem = async function (text, extra = {}) {
+    const in_conversation_item_obj = {
+      _id: response_conversation_item_id,
+      stat: 3,
+      docType: 'chat_conversation_item',
+      uid,
+      conversation_type: 'dashboard',
+      type: 'dashboard',
+      date_created_ts: Date.now(),
+      ts: Date.now(),
+      conversation_id,
+      text,
+      reference_id: conversation_doc.reference_id,
+      direction: 'in',
+      role: 'assistant',
+      read: { [uid]: Date.now() },
+      rtl: _common.detectRTL(text),
+      job_id,
+      context: dashboard_context,
+      target_app_id,
+      prompt_conversation_item_id,
+      ...extra,
+    };
+
+    return await db_module.save_app_couch_doc_native(account_profile_info.app_id, in_conversation_item_obj);
+  };
+
+  const formatDashboardHistoryItem = function (item) {
+    const role = item.role === 'assistant' ? 'Assistant' : 'User';
+    const type = item.conversation_type || item.type || 'message';
+    const file_name = item?.file?.filename ? ` file=${item.file.filename}` : '';
+    let text = (item.text || item.prompt || '').trim();
+    if (text.length > 2500) {
+      text = `${text.slice(0, 2500)}...`;
+    }
+
+    return `${role} (${type}${file_name}): ${text}`;
+  };
+
+  const getDashboardContextPrompt = async function () {
+    const ret = await db_module.find_app_couch_query(account_profile_info.app_id, {
+      selector: {
+        docType: 'chat_conversation_item',
+        conversation_id,
+        stat: 3,
+      },
+      limit: 12,
+      sort: [{ date_created_ts: 'desc' }],
+    });
+
+    const items = (ret.docs || []).reverse().filter((item) => item.text || item.prompt || item?.file?.filename);
+    const conversation_history = items.map(formatDashboardHistoryItem).join('\n\n');
+
+    return `You are handling the latest Xuda dashboard chat request.
+
+Dashboard context/tab: ${dashboard_context || 'unknown'}
+Target app_id/reference_id: ${target_app_id}
+
+Use the conversation history, attachment transcripts, and latest user message to infer the dashboard area when context is unknown.
+
+Conversation history:
+${conversation_history || `User (dashboard): ${prompt}`}
+`;
+  };
+
+  try {
+    emitToDashboard('stream_start');
+    emitToDashboard('stream_phase', dashboard_context === 'console' ? 'Starting console request' : 'Starting dashboard request');
+
+    await saveUserItem();
+
+    if (attachments?.length) {
+      emitToDashboard('stream_phase', 'Analyzing attachments', { update: true });
+      await attachment_handler(uid, account_profile_info.app_id, conversation_id, attachments, account_profile_info);
+    }
+
+    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 = 2;
+    conversation_doc.request_started_at = request_started_at;
+    conversation_doc.job_id = job_id;
+    conversation_doc.context = dashboard_context;
+    conversation_doc.target_app_id = target_app_id;
+    await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+
+    if (dashboard_context === 'console') {
+      const codex_ret = await execute_codex_request({ ...req, conversation_id, conversation_doc, prompt, attachments, stream: false }, job_id, headers);
+      const codex_events = codex_ret?.data?.events || [];
+      const last_message = [...codex_events].reverse().find((event) => event?.item?.type === 'agent_message' && event.item.text)?.item?.text;
+      const response_text = codex_ret.code < 0 ? `Console request failed: ${get_error_message(codex_ret.data, 'Codex request failed')}` : last_message || 'Console request completed.';
+
+      emitToDashboard('response_start');
+      streamText(response_text);
+      emitToDashboard('stream_end');
+
+      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 = codex_ret.code < 0 ? 'partial' : 'full';
+      await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+
+      return await saveAssistantItem(response_text, { codex_result: codex_ret });
+    }
+
+    const dashboard_prompt = await getDashboardContextPrompt();
+    const app_obj = await get_app_obj(target_app_id);
+    const userName = await account_ms.get_user_name(uid);
+    const account_info = (await get_account_name({ uid })).data;
+    const context = { ...{ app_id: target_app_id, uid, profile_id, userName, account_info, app_obj, account_id: uid, dashboard_context }, ...extractClientInfo(headers) };
+    const cpi_tools_ret = get_dashboard_cpi_tools({ uid, profile_id, gtp_token, app_id: target_app_id, context: dashboard_context, prompt: dashboard_prompt });
+
+    if (!cpi_tools_ret.tools.length) {
+      throw new Error(`no CPI methods available for dashboard context "${dashboard_context || 'unknown'}"`);
+    }
+
+    const agent = new Agent({
+      name: 'Dashboard CPI Agent',
+      instructions: `
+You are Xuda dashboard chat.
+The user is interacting with the dashboard tab/context "${dashboard_context || 'unknown'}" for app_id "${target_app_id}".
+Use the available CPI tools to inspect, update, or explain dashboard data. Prefer tool calls over guessing.
+If the screenshot or prompt implies the tab/context, infer the relevant dashboard area and choose the closest CPI method.
+For data/database requests, use the database/table CPI methods and keep app_id/reference_id anchored to "${target_app_id}".
+Summarize the action and important CPI result fields clearly. Do not invent successful changes; report tool errors as errors.
+Available CPI methods: ${cpi_tools_ret.selected_methods.join(', ')}
+`.trim(),
+      model: ai_model,
+      tools: cpi_tools_ret.tools,
+    });
+
+    agent.on('agent_tool_start', (context, tool) => {
+      emitToDashboard('stream_phase', `Starting ${tool?.name?.replaceAll('_', ' ')} tool`, { update: true });
+    });
+
+    emitToDashboard('stream_phase', 'Submitting dashboard request', { update: true });
+    const runner = new Runner();
+    const output = await runner.run(agent, dashboard_prompt, { context, stream });
+    let response_text = '';
+
+    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');
+        }
+        const text = chunk.toString();
+        response_text += text;
+        emitToDashboard('stream_delta', text);
+      }
+    }
+
+    response_text = response_text || output?.state?._currentStep?.output || output?.finalOutput || output?.output || 'Dashboard request completed.';
+    emitToDashboard('stream_end');
+
+    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 = 'full';
+    await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+
+    return await saveAssistantItem(response_text, {
+      cpi_methods: cpi_tools_ret.selected_methods,
+      ai_agent_id: 'dashboard_cpi_agent',
+    });
+  } catch (err) {
+    const error_message = get_error_message(err, 'dashboard request failed');
+    emitToDashboard('stream_phase', 'Dashboard request failed', { update: true });
+    emitToDashboard('response_start');
+    streamText(`Dashboard request failed: ${error_message}`);
+    emitToDashboard('stream_end');
+
+    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);
+
+    return { code: -17, data: error_message };
+  }
+};
+
 const get_ai_agent_tools = async function ({ ai_agent_doc, agent_id, reference_type, prompt_suggestion_activated, chat_suggestion_activated, gtp_token, uid, account_profile_info, job_id, headers, context, app_id }) {
   let tools = [];
   let tool_resources = {};

package/package.json

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