@xuda.io/ai_module 1.1.5572 → 1.1.5573

package/index.mjs

@@ -3,6 +3,7 @@ console.log('AI Module loaded...');
 import { z } from 'zod';
 import fs from 'fs';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 import sharp from 'sharp';
 
@@ -3567,6 +3568,46 @@ function getFirstNWords(text, n = 10) {
   return words.slice(0, n).join(' ');
 }
 
+const get_error_message = function (err, fallback = 'Unknown error') {
+  if (!err) return fallback;
+
+  if (typeof err === 'string') {
+    return err;
+  }
+
+  if (err instanceof Error) {
+    return err.message || fallback;
+  }
+
+  if (typeof err?.message === 'string' && err.message) {
+    return err.message;
+  }
+
+  if (typeof err?.data === 'string' && err.data) {
+    return err.data;
+  }
+
+  try {
+    const serialized = JSON.stringify(err);
+    if (serialized && serialized !== '{}') {
+      return serialized;
+    }
+  } catch (error) {}
+
+  return String(err);
+};
+
+const get_plugin_import_specifier = function (app_id, plugin_name, resource, dev = true) {
+  const absolute_path = dev ? path.join(process.env.XUDA_HOME, 'plugins', plugin_name, resource) : path.join(_conf.plugins_drive_path, app_id, 'node_modules', plugin_name, resource);
+
+  const file_url = pathToFileURL(absolute_path);
+  if (dev) {
+    file_url.searchParams.set('ts', `${Date.now()}`);
+  }
+
+  return file_url.href;
+};
+
 export const create_openai_conversation = async function () {
   return await client.conversations.create();
 };
@@ -3609,7 +3650,7 @@ export const create_conversation = async function (req, job_id, headers) {
       title: conversation_type !== 'email' ? getFirstNWords(prompt, 10) : prompt,
       date_created_ts: date_created ? new Date(date_created).getTime() : d,
       ts: d,
-      stat: !conversation_type || conversation_type === 'ai_chat' ? 1 : 3,
+      stat: !conversation_type || ['ai_chat', 'studio'].includes(conversation_type) ? 1 : 3,
       uid,
       messages: [],
       reference_type,
@@ -3728,6 +3769,11 @@ const process_conversation = async function (uid, conversation_id, account_profi
         break;
       }
 
+      case 'studio': {
+        category_info = await categorize_ai_prompt(uid, prompt, account_profile_info);
+        break;
+      }
+
       case 'email': {
         category_info = await categorize_email_subject(uid, prompt, account_profile_info);
         break;
@@ -3812,7 +3858,9 @@ export const submit_chat_conversation = async function (req, job_id, headers) {
     let conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_id);
     req.conversation_doc = conversation_doc;
     let ret;
-    if (conversation_doc.reference_type === 'contacts') {
+    if (conversation_doc.conversation_type === 'studio') {
+      ret = await chat_studio(req, job_id, headers);
+    } else if (conversation_doc.reference_type === 'contacts') {
       req._thread_reentry = Date.now() - conversation_doc.date_created_ts > 60000;
 
       account_msa.ts_contact(uid, conversation_doc.reference_id);
@@ -4127,6 +4175,336 @@ 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;
+
+  const conversation_id = conversation_doc._id;
+  const normalized_plan_mode = typeof plan_mode === 'string' ? ['true', '1', 'yes', 'on'].includes(plan_mode.toLowerCase()) : Boolean(plan_mode);
+  const save_result_to_studio = normalized_plan_mode ? false : true;
+  const plugin_name = '@xuda.io/xuda-library-plugin-studio-ai-app-builder';
+  const plugin_method = normalized_plan_mode ? 'app_planner' : 'app_builder';
+  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 emitToDashboard = (type, content, params) => {
+    ws_dashboard_msa.emit_message_to_dashboard({
+      service: type,
+      to: uid,
+      data: {
+        conversation_id,
+        job_id,
+        delta: content,
+        prompt_conversation_item_id,
+        response_conversation_item_id,
+        params,
+      },
+    });
+  };
+
+  let response_started = false;
+  const ensureResponseStarted = function () {
+    if (!response_started) {
+      response_started = true;
+      emitToDashboard('response_start');
+    }
+  };
+
+  const emitStreamDelta = function (text) {
+    if (!text) return;
+    ensureResponseStarted();
+    emitToDashboard('stream_delta', text);
+  };
+
+  const streamText = function (text, chunk_size = 280) {
+    if (!stream || !text) return;
+    for (let i = 0; i < text.length; i += chunk_size) {
+      emitStreamDelta(text.slice(i, i + chunk_size));
+    }
+  };
+
+  const emitThinkingPhase = function (content) {
+    if (!content) return;
+    emitToDashboard('stream_phase', content.trim(), { update: true });
+  };
+
+  const formatConversationHistoryItem = 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 > 2000) {
+      text = `${text.slice(0, 2000)}...`;
+    }
+
+    return `${role} (${type}${file_name}): ${text}`;
+  };
+
+  const get_studio_context_prompt = 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(formatConversationHistoryItem).join('\n\n');
+
+    return `You are working inside Xuda Studio.
+
+Use the conversation history below as the main source of context for the current studio task.
+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.
+
+Conversation history:
+${conversation_history || `User (studio): ${prompt}`}
+`;
+  };
+
+  const get_studio_result_message = function (studio_result) {
+    if (normalized_plan_mode) {
+      if (typeof studio_result === 'string') {
+        return studio_result;
+      }
+
+      const approval_units = studio_result?.approval_units || [];
+      const build_order = studio_result?.build_order || [];
+      const acceptance_checks = studio_result?.acceptance_checks || [];
+
+      const lines = [`Studio plan ready.`, ``, `Thinking:`, `- Mapped the request into ${approval_units.length} planned Xuda unit${approval_units.length === 1 ? '' : 's'}.`, `- Kept this turn in planning mode, so no studio docs were saved.`];
+
+      if (studio_result?.overview) {
+        lines.push('', 'Overview', studio_result.overview);
+      }
+
+      if (approval_units.length) {
+        lines.push('', 'Planned units');
+        for (const unit of approval_units.slice(0, 12)) {
+          lines.push(`- ${unit.unit_type}: ${unit.unit_name}${unit.folder_name ? ` (${unit.folder_name})` : ''}`);
+        }
+      }
+
+      if (build_order.length) {
+        lines.push('', 'Build order');
+        for (const step of build_order.slice(0, 8)) {
+          lines.push(`- ${step.step}. ${step.block_ref}: ${step.deliverable}`);
+        }
+      }
+
+      if (acceptance_checks.length) {
+        lines.push('', 'Acceptance checks');
+        for (const check of acceptance_checks.slice(0, 8)) {
+          lines.push(`- ${check}`);
+        }
+      }
+
+      return lines.join('\n');
+    }
+
+    const docs = Array.isArray(studio_result?.docs) ? studio_result.docs.filter(Boolean) : _.castArray(studio_result).filter(Boolean);
+    const grouped_docs = _.countBy(docs, (doc) => doc?.properties?.menuType || 'unknown');
+    const grouped_docs_summary = Object.entries(grouped_docs)
+      .map(([type, count]) => `${count} ${type}`)
+      .join(', ');
+
+    const lines = [save_result_to_studio ? `Studio build completed and saved.` : `Studio build completed.`, ``, `Thinking:`, `- Turned the request into ${docs.length} studio doc${docs.length === 1 ? '' : 's'}.`];
+
+    if (grouped_docs_summary) {
+      lines.push(`- Generated ${grouped_docs_summary}.`);
+    }
+
+    lines.push(save_result_to_studio ? `- Saved the generated docs into the current studio project.` : `- Returned the generated docs without saving them.`);
+
+    if (docs.length) {
+      lines.push('', 'Created units');
+      for (const doc of docs.slice(0, 12)) {
+        const menu_type = doc?.properties?.menuType || 'doc';
+        const menu_name = doc?.properties?.menuName || doc?.properties?.menuTitle || doc?._id || 'Unnamed';
+        lines.push(`- ${menu_type}: ${menu_name}${doc?._id ? ` [${doc._id}]` : ''}`);
+      }
+    }
+
+    return lines.join('\n');
+  };
+
+  let thinking_interval;
+  let thinking_index = 0;
+  const thinking_messages = normalized_plan_mode
+    ? ['Thinking through the request and mapping it into Xuda units...\n\n', 'Checking which folders, tables, globals, and runtime blocks are needed...\n\n', 'Drafting a studio floor plan for approval...\n\n']
+    : ['Thinking through the request and deciding what should be created in Studio...\n\n', 'Checking which Xuda docs are required before building...\n\n', 'Preparing the app builder plugin to generate and save the result...\n\n'];
+
+  try {
+    emitToDashboard('stream_start');
+    emitToDashboard('stream_phase', normalized_plan_mode ? 'Planning studio request' : 'Building studio request');
+
+    const conversation_item_reference_id = await add_conversation_item(uid, profile_id, conversation_id, prompt, 'studio', undefined, { plan_mode: normalized_plan_mode });
+
+    let out_conversation_item_obj = {
+      _id: prompt_conversation_item_id,
+      stat: 3,
+      docType: 'chat_conversation_item',
+      uid,
+      conversation_type: 'studio',
+      type: 'studio',
+      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,
+      plan_mode: normalized_plan_mode,
+      studio_method: plugin_method,
+      target_app_id,
+    };
+
+    const out_conversation_item_save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, out_conversation_item_obj);
+    if (out_conversation_item_save_ret.code < 0) throw new Error(out_conversation_item_save_ret.data);
+
+    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.job_id = job_id;
+    conversation_doc.plan_mode = normalized_plan_mode;
+    conversation_doc.target_app_id = target_app_id;
+    await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+
+    emitToDashboard('stream_phase', normalized_plan_mode ? 'Preparing studio plan' : 'Preparing studio build', { update: true });
+    emitThinkingPhase(thinking_messages[thinking_index]);
+
+    if (thinking_messages.length > 1) {
+      thinking_interval = setInterval(async () => {
+        if (thinking_index >= thinking_messages.length - 1) {
+          clearInterval(thinking_interval);
+          thinking_interval = undefined;
+          return;
+        }
+
+        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;
+            }
+          }
+        } catch (error) {}
+
+        emitThinkingPhase(thinking_messages[thinking_index]);
+
+        if (thinking_index >= thinking_messages.length - 1) {
+          clearInterval(thinking_interval);
+          thinking_interval = undefined;
+        }
+      }, 1800);
+    }
+
+    const studio_prompt = await get_studio_context_prompt();
+    const plugin_ret = await run_plugin(
+      target_app_id,
+      uid,
+      plugin_name,
+      plugin_method,
+      {
+        prompt: studio_prompt,
+        save: save_result_to_studio,
+      },
+      true,
+      {
+        ...req,
+        prompt: studio_prompt,
+        plan_mode: normalized_plan_mode,
+        target_app_id,
+      },
+      true,
+      {
+        conversation_id,
+        conversation_type: 'studio',
+        plan_mode: normalized_plan_mode,
+      },
+    );
+
+    clearInterval(thinking_interval);
+    thinking_interval = undefined;
+
+    if (!plugin_ret || plugin_ret.code < 0) {
+      throw new Error(get_error_message(plugin_ret?.data || plugin_ret, 'studio plugin failed'));
+    }
+
+    const studio_result = plugin_ret.data;
+    const response_text = get_studio_result_message(studio_result);
+
+    emitToDashboard('stream_phase', normalized_plan_mode ? 'Streaming studio plan' : 'Streaming studio result', { update: true });
+    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 = 'full';
+    await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+
+    const in_conversation_item_obj = {
+      _id: response_conversation_item_id,
+      stat: 3,
+      docType: 'chat_conversation_item',
+      uid,
+      conversation_type: 'studio',
+      type: 'studio',
+      date_created_ts: Date.now(),
+      ts: Date.now(),
+      conversation_id,
+      text: response_text,
+      reference_id: conversation_doc.reference_id,
+      direction: 'in',
+      role: 'assistant',
+      read: { [uid]: Date.now() },
+      rtl: _common.detectRTL(response_text),
+      job_id,
+      plan_mode: normalized_plan_mode,
+      studio_method: plugin_method,
+      studio_result,
+      target_app_id,
+      prompt_conversation_item_id,
+    };
+
+    return await db_module.save_app_couch_doc_native(account_profile_info.app_id, in_conversation_item_obj);
+  } catch (err) {
+    if (thinking_interval) {
+      clearInterval(thinking_interval);
+    }
+
+    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;
+    await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+
+    const error_message = get_error_message(err, 'studio request failed');
+    emitToDashboard('stream_phase', 'Studio request failed', { update: true });
+    streamText(`Studio request failed: ${error_message}`);
+    emitToDashboard('stream_end');
+
+    return { code: -16, 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 = {};
@@ -5162,7 +5540,7 @@ const add_conversation_item = async function (uid, profile_id, conversation_id,
     } catch (err) {
       throw err;
     }
-    if (contact_id) {
+    if (conversation_doc.reference_type === 'contacts' && contact_id) {
       try {
         let contact_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, contact_id);
         const item = await client.conversations.items.create(contact_doc.contact_reference_conversation_id, {
@@ -5467,17 +5845,10 @@ setTimeout(async () => {
 const run_plugin = async function (app_id, uid, plugin_name, method, prop_data, dev = true, req = {}, testing = true, agent_info = {}) {
   const db_module = await import(`${module_path}/db_module/index.mjs`);
   debugger;
-  const get_path = function (resource) {
-    if (dev) {
-      return `../../plugins/${plugin_name}/${resource}`;
-    }
-
-    return `${_conf.plugins_drive_path}/${app_id}/node_modules/${plugin_name}/${resource}`;
-  };
   const get_plugin_resource = function (plugin_name, plugin_resource) {
     return new Promise(async (resolve, reject) => {
       try {
-        const plugin_resource_res = await import(`${get_path(plugin_resource)}`);
+        const plugin_resource_res = await import(get_plugin_import_specifier(app_id, plugin_name, plugin_resource, dev));
         resolve(plugin_resource_res);
       } catch (err) {
         console.error(err);
@@ -5560,8 +5931,7 @@ const run_plugin = async function (app_id, uid, plugin_name, method, prop_data,
         };
 
         const reject_local = function (e) {
-          reject({ code: -1, data: e });
-          // reject(e.message);
+          reject(new Error(get_error_message(e, 'plugin execution failed')));
         };
 
         try {
@@ -5604,17 +5974,10 @@ const get_plugin_tool = async function (app_id, uid, plugin_name, method, prop_d
 
   init(undefined, undefined, _, true, undefined, undefined, undefined, undefined, undefined, true, z);
 
-  const get_path = function (resource) {
-    if (dev) {
-      return `../../plugins/${plugin_name}/${resource}`;
-    }
-
-    return `${_conf.plugins_drive_path}/${app_id}/node_modules/${plugin_name}/${resource}`;
-  };
   const get_plugin_resource = function (plugin_name, plugin_resource) {
     return new Promise(async (resolve, reject) => {
       try {
-        const plugin_resource_res = await import(`${get_path(plugin_resource)}`);
+        const plugin_resource_res = await import(get_plugin_import_specifier(app_id, plugin_name, plugin_resource, dev));
         resolve(plugin_resource_res);
       } catch (err) {
         console.error(err);
@@ -5692,8 +6055,7 @@ const get_plugin_tool = async function (app_id, uid, plugin_name, method, prop_d
         };
 
         const reject_local = function (e) {
-          reject({ code: -1, data: e });
-          // reject(e.message);
+          reject(new Error(get_error_message(e, 'plugin execution failed')));
         };
 
         try {

package/package.json

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