@xuda.io/ai_module 1.1.5611 → 1.1.5613

package/index.mjs

@@ -232,7 +232,7 @@ const email_ms = await import(`${module_path}/email_module/index_ms.mjs`);
 const ws_dashboard_msa = await import(`${module_path}/ws_dashboard_module/index_msa.mjs`);
 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 npm_publish_msa = await import(`${module_path}/npm_publish_module/index_msa.mjs`);
+const misc_msa = await import(`${module_path}/misc_module/index_msa.mjs`);
 
 var open_ai_status = {};
 const report_ai_status = function (model, err) {
@@ -2151,7 +2151,7 @@ const get_studio_doc = async function (req) {
 };
 
 export const get_ai_agent_info = async function (uid, job_id, headers, doc, from_marketplace) {
-  const account_profile_info = await get_active_account_profile_info(uid);
+  const account_profile_info = await get_active_account_profile_info(uid, from_marketplace ? doc?.studio_meta?.account_profiles?.[0] : undefined);
 
   const get_contact_border = function (doc) {
     const disable_color = `#1a3557`;
@@ -2673,7 +2673,7 @@ export const delete_ai_agent = async function (req) {
       const save_ret = await db_module.save_app_couch_doc_native(account_profile_info.app_id, agent_doc);
 
       if (agent_doc?.agentConfig?.npm_package_name) {
-        npm_publish_msa.sync_agent_npm_state({ app_id: account_profile_info.app_id, prog_id: agent_id, event: 'deleted' });
+        misc_msa.sync_agent_npm_state({ app_id: account_profile_info.app_id, prog_id: agent_id, event: 'deleted' });
       }
 
       for (const [key, val] of Object.entries(agent_doc?.agentConfig?.agent_tools || [])) {
@@ -2894,6 +2894,8 @@ export const start_cli_agent_conversation = async function (req) {
   if (!agent_id) return { code: -1, data: 'agent_id required' };
   try {
     const account_profile_info = await get_active_account_profile_info(uid);
+    const profile_id = account_profile_info.account_profile_id;
+    const conversation_obj = await create_openai_conversation();
     const conversation_id = await _common.xuda_get_uuid('chat_conversation');
     const now = Date.now();
     const doc = {
@@ -2907,23 +2909,25 @@ export const start_cli_agent_conversation = async function (req) {
       messages: [],
       reference_type: 'ai_agents',
       reference_id: agent_id,
+      conversation_obj,
+      reference_conversation_id: conversation_obj.id,
       conversation_type: 'ai_chat',
       initiator_uid: uid,
-      account_profiles: [account_profile_info._id],
+      account_profiles: [profile_id],
       source: 'cli',
     };
     const save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, doc);
     if (save_ret.code < 0) return save_ret;
-    return { code: 1, data: { conversation_id, profile_id: account_profile_info._id, app_id: account_profile_info.app_id } };
+    return { code: 1, data: { conversation_id, profile_id, app_id: account_profile_info.app_id } };
   } catch (err) {
     return { code: -1, data: err.message };
   }
 };
 
 export const update_ai_agent = async function (req, job_id, headers) {
-  let { agent_id, agentConfig, uid } = req;
+  let { agent_id, agentConfig, uid, profile_id } = req;
 
-  const account_profile_info = await get_active_account_profile_info(uid);
+  const account_profile_info = await get_active_account_profile_info(uid, profile_id);
 
   try {
     let agent_doc = await await db_module.get_app_couch_doc_native(account_profile_info.app_id, agent_id);
@@ -3329,11 +3333,11 @@ const save_agent_status = async function (uid, agent_id, stat, agentConfig) {
 };
 
 export const create_ai_agent = async function (req, job_id, headers) {
-  const { agentConfig, uid } = req;
+  const { agentConfig, uid, profile_id } = req;
 
   const { account_project_id: app_id, account_info } = await account_ms.get_default_project_account_doc(uid);
 
-  const account_profile_info = await get_active_account_profile_info(uid);
+  const account_profile_info = await get_active_account_profile_info(uid, profile_id);
   const { account_profile_obj } = account_profile_info;
   try {
     const param = { uid, properties: { menuName: agentConfig.agent_name, menuTitle: agentConfig.agent_name, menuType: 'ai_agent' }, checkedInUserName: account_info.first_name + ' ' + account_info.last_name, app_id: account_profile_info.app_id, parentId: 'ai_agents' };
@@ -3611,7 +3615,7 @@ export const update_thumbnail = async function (type, doc, app_id, uid, job_id,
 
     switch (type) {
       case 'ai_agent': {
-        const images_arr = await create_ai_agent_image({ app_id, uid, ai_agent_id: doc._id, tags }, job_id, headers);
+        const images_arr = await create_ai_agent_image({ app_id, uid, ai_agent_id: doc._id, tags, account_profile_info }, job_id, headers);
         db_doc = await get_db_doc();
         db_doc.studio_meta.thumbnail_request_ts = Date.now();
         db_doc.studio_meta.agent_image = [images_arr.data];
@@ -4262,14 +4266,17 @@ export const create_conversation = async function (req, job_id, headers) {
           // write conversation to host after thumbnail update
           // get sender conversation
 
-          const conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_doc._id);
+          // Re-fetch the freshest copy of the conversation doc after process_conversation
+          // had a chance to write thumbnail / title updates. Renamed (was `conversation_doc`)
+          // to avoid TDZ shadowing the outer-scope `conversation_doc` we read for the lookup id.
+          const fresh_conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_doc._id);
 
           const recipient_account_profile_info = await get_active_account_profile_info(recipient_uid);
-          let recipient_conversation_doc = await db_module.get_app_couch_doc_native(recipient_account_profile_info.app_id, conversation_doc._id);
-          recipient_conversation_doc.title = conversation_doc.title;
+          let recipient_conversation_doc = await db_module.get_app_couch_doc_native(recipient_account_profile_info.app_id, fresh_conversation_doc._id);
+          recipient_conversation_doc.title = fresh_conversation_doc.title;
 
-          recipient_conversation_doc.thumbnail_request_ts = conversation_doc.thumbnail_request_ts;
-          recipient_conversation_doc.chat_image = conversation_doc.chat_image;
+          recipient_conversation_doc.thumbnail_request_ts = fresh_conversation_doc.thumbnail_request_ts;
+          recipient_conversation_doc.chat_image = fresh_conversation_doc.chat_image;
           recipient_conversation_doc.direction = 'in';
           await db_module.save_app_couch_doc_native(recipient_account_profile_info.app_id, recipient_conversation_doc);
 
@@ -5742,9 +5749,328 @@ const get_ai_agent_tools = async function ({ ai_agent_doc, agent_id, reference_t
   let tool_resources = {};
   let eligible_agent = true;
 
+  const add_internal_codex_tool = function ({ name, description, system_prompt }) {
+    if (reference_type !== 'ai_agents' && !prompt_suggestion_activated && !chat_suggestion_activated) {
+      eligible_agent = false;
+      return;
+    }
+
+    tools.push(
+      tool({
+        name: name.substring(0, 60),
+        description,
+        parameters: z.object({
+          question: z.string().describe('The support question to investigate.'),
+        }),
+        async execute(e) {
+          const question = String(e?.question || '').trim();
+          if (!question) {
+            return 'question is required';
+          }
+
+          const dev_host = _conf?.internal_ai_agents?.dev_server_host || 'dev.xuda.ai';
+          const codex_ret = await execute_codex_request(
+            {
+              ip: dev_host,
+              uid,
+              account_profile_info,
+              job_id,
+              stream: false,
+              prompt: `${system_prompt}
+
+User question:
+${question}
+
+Return a concise answer. Include only non-sensitive findings and mention when the requested information is outside the allowed scope.`,
+            },
+            job_id,
+            headers,
+          );
+
+          if (codex_ret.code < 0) {
+            return `Codex readonly lookup failed: ${get_error_message(codex_ret.data, 'unknown error')}`;
+          }
+
+          const events = codex_ret?.data?.events || [];
+          const final_message = [...events].reverse().find((event) => event?.item?.type === 'agent_message' && event.item.text)?.item?.text;
+          return final_message || 'Codex readonly lookup completed without a final answer.';
+        },
+      }),
+    );
+  };
+
+  const add_xuda_public_website_tool = function ({ name, description }) {
+    if (reference_type !== 'ai_agents' && !prompt_suggestion_activated && !chat_suggestion_activated) {
+      eligible_agent = false;
+      return;
+    }
+
+    const website_origin = _conf?.internal_ai_agents?.public_website_url || 'https://xuda.ai';
+    const dump_dir = path.join(os.tmpdir(), 'xuda_public_website_dump', new URL(website_origin).hostname.replace(/[^a-z0-9.-]/gi, '_'));
+    const manifest_path = path.join(dump_dir, 'manifest.json');
+    const ttl_ms = Number(_conf?.internal_ai_agents?.public_website_dump_ttl_ms || 10 * 60 * 1000);
+    const cache_version = 2;
+    const website_base = website_origin.replace(/\/$/, '');
+
+    const decode_html = function (value = '') {
+      return String(value)
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/&amp;/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/g, "'");
+    };
+
+    const strip_html = function (html = '') {
+      return decode_html(
+        String(html)
+          .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+          .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+          .replace(/<noscript[\s\S]*?<\/noscript>/gi, ' ')
+          .replace(/<svg[\s\S]*?<\/svg>/gi, ' ')
+          .replace(/<[^>]+>/g, ' ')
+          .replace(/\s+/g, ' ')
+          .trim(),
+      );
+    };
+
+    const extract_title = function (html = '') {
+      const match = String(html).match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+      return match ? decode_html(match[1]).replace(/\s+/g, ' ').trim() : '';
+    };
+
+    const get_terms = function (question) {
+      const terms = String(question)
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .split(/\s+/)
+        .filter((term) => term.length > 2 && !['the', 'and', 'for', 'about', 'tell', 'with', 'from', 'what', 'who', 'how', 'xuda'].includes(term));
+      if (/\baddress|where|location|located|office|contact\b/i.test(question)) {
+        terms.push('address', 'contact', 'llc', 'boca', 'raton', 'florida');
+      }
+      return [...new Set(terms)];
+    };
+
+    const score_page = function (page, terms, question) {
+      const haystack = `${page.url} ${page.title} ${page.text}`.toLowerCase();
+      let score = 0;
+      for (const term of terms) {
+        if (haystack.includes(term)) score += term.length > 4 ? 3 : 1;
+      }
+      if (/\b(company|about|xuda)\b/i.test(question) && new URL(page.url).pathname === '/') score += 20;
+      if (/\bdocs?|guide|how|cli|dashboard|deploy|agent|app|vps|database|couchdb\b/i.test(question) && page.url.includes('/docs')) score += 8;
+      if (/\bnetwork|ambassador|mentor|city|region\b/i.test(question) && page.url.includes('network')) score += 8;
+      if (/\baddress|where|location|located|office|contact\b/i.test(question) && /\/legal\/privacy-policy/i.test(page.url)) score += 100;
+      if (/\baddress|where|location|located|office|contact\b/i.test(question) && /\/legal\/terms|contact/i.test(page.url)) score += 30;
+      return score;
+    };
+
+    const make_snippet = function (text = '', terms = [], max_length = 3000) {
+      const lower = text.toLowerCase();
+      const anchors = ['address', 'contact us', 'xuda llc', 'boca raton', 'florida', ...terms];
+      let index = -1;
+      for (const anchor of anchors) {
+        index = lower.indexOf(String(anchor).toLowerCase());
+        if (index > -1) break;
+      }
+      if (index < 0) return text.slice(0, max_length);
+      const start = Math.max(0, index - Math.floor(max_length / 3));
+      const end = Math.min(text.length, start + max_length);
+      return `${start > 0 ? '...' : ''}${text.slice(start, end)}${end < text.length ? '...' : ''}`;
+    };
+
+    const extract_public_facts = function (page, question) {
+      const facts = [];
+      if (/\baddress|where|location|located|office|contact\b/i.test(question)) {
+        const address_match = String(page.text || '').match(/Address:\s*([^|]+?)(?=\s+By using|\s+Privacy Policy|\s+Terms|\s*$)/i);
+        if (address_match?.[1]) {
+          facts.push({
+            label: 'Address',
+            value: address_match[1].replace(/\s+/g, ' ').trim(),
+            url: page.url,
+          });
+        }
+      }
+      return facts;
+    };
+
+    const fetch_text = async function (url, timeout_ms = 8000) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout_ms);
+      try {
+        const res = await fetch(url, {
+          signal: controller.signal,
+          headers: { 'User-Agent': 'Xuda Ambassador Support Readonly Website Indexer' },
+        });
+        if (!res.ok) throw new Error(`${url} returned ${res.status}`);
+        return await res.text();
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+
+    const load_dump = async function () {
+      try {
+        const manifest = JSON.parse(await fs.promises.readFile(manifest_path, 'utf8'));
+        if (Number(manifest.cache_version || 0) === cache_version && Date.now() - Number(manifest.created_ts || 0) < ttl_ms && Array.isArray(manifest.pages) && manifest.pages.length) {
+          const pages = [];
+          for (const page of manifest.pages) {
+            try {
+              pages.push(JSON.parse(await fs.promises.readFile(path.join(dump_dir, page.file), 'utf8')));
+            } catch (_) {
+              /* ignore corrupt cache item */
+            }
+          }
+          if (pages.length) return { pages, from_cache: true };
+        }
+      } catch (_) {
+        /* build cache below */
+      }
+
+      await fs.promises.mkdir(dump_dir, { recursive: true });
+      const sitemap_xml = await fetch_text(`${website_base}/sitemap.xml`, 8000);
+      const priority_urls = [`${website_base}/`, `${website_base}/about`, `${website_base}/legal/privacy-policy`, `${website_base}/legal/terms`, `${website_base}/contact`];
+      const sitemap_urls = [...sitemap_xml.matchAll(/<loc>([\s\S]*?)<\/loc>/gi)]
+        .map((match) => decode_html(match[1]).trim())
+        .filter((url) => {
+          try {
+            const parsed = new URL(url);
+            return parsed.origin === website_base && !/\.(png|jpe?g|gif|webp|svg|pdf|zip)$/i.test(parsed.pathname);
+          } catch (_) {
+            return false;
+          }
+        })
+        .slice(0, 120);
+      const urls = [...new Set([...priority_urls, ...sitemap_urls])];
+
+      const pages = [];
+      for (const url of urls) {
+        try {
+          const html = await fetch_text(url, 8000);
+          const page = {
+            url,
+            title: extract_title(html),
+            text: strip_html(html).slice(0, 80000),
+            fetched_ts: Date.now(),
+          };
+          if (page.text.length < 80) continue;
+          const file = `${crypto.createHash('sha1').update(url).digest('hex')}.json`;
+          await fs.promises.writeFile(path.join(dump_dir, file), JSON.stringify(page, null, 2));
+          pages.push({ ...page, file });
+        } catch (err) {
+          pages.push({ url, title: '', text: `Fetch failed: ${err.message || String(err)}`, fetch_error: true });
+        }
+      }
+
+      await fs.promises.writeFile(
+        manifest_path,
+        JSON.stringify(
+          {
+            source: website_origin,
+            cache_version,
+            created_ts: Date.now(),
+            pages: pages.filter((page) => !page.fetch_error).map((page) => ({ url: page.url, file: page.file, title: page.title })),
+          },
+          null,
+          2,
+        ),
+      );
+      return { pages, from_cache: false };
+    };
+
+    tools.push(
+      tool({
+        name: (name || 'Xuda Ambassador Public Website Readonly').substring(0, 60),
+        description: description || 'Readonly lookup against public xuda.ai website pages for ambassador support answers.',
+        parameters: z.object({
+          question: z.string().describe('The support question to answer from public xuda.ai website pages.'),
+        }),
+        async execute(e) {
+          const question = String(e?.question || '').trim();
+          if (!question) {
+            return 'question is required';
+          }
+
+          const run_lookup = async function () {
+            const { pages } = await load_dump();
+            const terms = get_terms(question);
+            const ranked = pages
+              .filter((page) => !page.fetch_error)
+              .map((page) => ({ page, score: score_page(page, terms, question) }))
+              .filter((item) => item.score > 0)
+              .sort((a, b) => b.score - a.score)
+              .slice(0, 5)
+              .map((item) => ({
+                score: item.score,
+                url: item.page.url,
+                title: item.page.title,
+                snippet: make_snippet(item.page.text, terms),
+              }));
+            const facts = pages
+              .filter((page) => !page.fetch_error)
+              .flatMap((page) => extract_public_facts(page, question))
+              .slice(0, 5);
+
+            return {
+              source: website_origin,
+              readonly: true,
+              question,
+              facts,
+              result_count: ranked.length,
+              results: ranked,
+              instruction: ranked.length
+                ? 'Answer only from these public xuda.ai website facts and snippets. If facts are present, use them as the primary source. Cite page URLs inline when useful. Do not mention internal cache, dump folders, or implementation details.'
+                : 'No relevant public xuda.ai pages were found. Say that the public xuda.ai website did not contain enough information and ask for a narrower page or topic. Do not mention internal cache, dump folders, or implementation details.',
+            };
+          };
+
+          try {
+            const data = await Promise.race([run_lookup(), new Promise((_, reject) => setTimeout(() => reject(new Error('xuda.ai website lookup timed out')), 20000))]);
+            return JSON.stringify(data, null, 2);
+          } catch (err) {
+            return `xuda.ai website lookup failed: ${err.message || String(err)}`;
+          }
+        },
+      }),
+    );
+  };
+
   for (const [key, val] of Object.entries(ai_agent_doc?.agentConfig?.agent_tools || [])) {
     const { name = '', description = '' } = val;
     switch (val.type) {
+      case 'xuda_network_ambassador_dev_couchdb_readonly': {
+        add_xuda_public_website_tool({
+          name: name || 'Xuda Ambassador Public Website Readonly',
+          description: description || 'Readonly lookup against public xuda.ai website pages for ambassador support answers.',
+        });
+        break;
+      }
+
+      case 'xuda_network_mentor_dev_server_readonly': {
+        add_internal_codex_tool({
+          name: name || 'Xuda Mentor Dev Server Readonly',
+          description: description || 'Readonly Codex lookup on /var/xuda of the dev server for technical mentor answers.',
+          system_prompt: `You are Codex helping a Xuda Network mentor answer technical questions about the Xuda codebase.
+
+Scope:
+- You may inspect only the dev server ${_conf?.internal_ai_agents?.dev_server_host || 'dev.xuda.ai'}.
+- You may use SSH only for readonly inspection.
+- You may read only under /var/xuda.
+- Prefer safe inspection commands such as pwd, ls, find, rg, sed -n, head, tail, wc, git status, git diff --stat, git log --oneline, and git show.
+
+Hard restrictions:
+- Never access config, config_dev, .env files, secret folders, SSH keys, certificates, credential files, database dumps, backups, logs likely to contain credentials, or any path outside /var/xuda.
+- Never query CouchDB or any database.
+- Never use network commands to call internal services.
+- Never run commands that write, mutate, install, delete, restart, deploy, publish, chmod/chown, kill processes, or change system state.
+- Never reveal passwords, tokens, API keys, private keys, names of private people, private emails, personal information, customer data, security details, or anything that could harm Xuda, its team, customers, or product security.
+- If the answer requires forbidden access, say it is outside the readonly mentor scope.
+- If sensitive data appears accidentally, do not quote it. State that sensitive output was omitted.`,
+        });
+        break;
+      }
+
       case 'web_search': {
         tools.push(webSearchTool());
         break;
@@ -6033,8 +6359,8 @@ const load_ai_agent_doc = async function (app_id, agent_id) {
       ai_agent_doc.reference_doc = reference_doc;
     } else if (ai_agent_doc.studio_meta.installed_from_app_uid) {
       const reference_doc = _.cloneDeep(ai_agent_doc);
-      await get_account_default_project_id(ai_agent_doc.studio_meta.installed_from_app_uid);
-      ai_agent_doc = await db_module.get_app_couch_doc_native(app_id, ai_agent_doc.studio_meta.share_item_id);
+      const source_app_id = ai_agent_doc.studio_meta.installed_from_app_id || (await get_account_default_project_id(ai_agent_doc.studio_meta.installed_from_app_uid));
+      ai_agent_doc = await db_module.get_app_couch_doc_native(source_app_id, ai_agent_doc.studio_meta.share_item_id || ai_agent_doc._id);
       ai_agent_doc.reference_doc = reference_doc;
     }
 
@@ -7406,10 +7732,10 @@ const get_plugin_tool = async function (app_id, uid, plugin_name, method, prop_d
   }
 };
 
-const create_and_upload_image_to_drive = async function (drive_type, file_path, file_name, prompt, numGenerations, uid, app_id, job_id, headers = {}, is_system, tags = [], account_profile_info) {
+const create_and_upload_image_to_drive = async function (drive_type, file_path, file_name, prompt, numGenerations, uid, app_id, job_id, headers = {}, is_system, tags = [], account_profile_info, width = 256, height = 256) {
   try {
     // 1. Generate the images
-    let result = await create_image(uid, prompt, undefined, undefined, numGenerations, undefined, undefined, { drive_type, file_path, file_name }, account_profile_info);
+    let result = await create_image(uid, prompt, undefined, undefined, numGenerations, width, height, { drive_type, file_path, file_name }, account_profile_info);
 
     // Normalize to array
     const images = Array.isArray(result) ? result : [result];
@@ -7865,6 +8191,14 @@ export const get_profile_picture = async function (uid, account_type = 'business
   const uniqueId = Date.now() + '_' + Math.random().toString(36).substring(7);
   const tempOutputPath = path.join(tempDir, `output_${uniqueId}.png`);
 
+  // Normalize: visitor accounts created through the chat widget can arrive with
+  // account_type missing, null, or some other value. Treat anything that isn't
+  // explicitly 'business' as 'personal' so the chat flow doesn't crash before
+  // ever reaching the agent reply.
+  if (account_type !== 'personal' && account_type !== 'business') {
+    account_type = 'personal';
+  }
+
   const { email, create_avatar } = metadata;
 
   let prompt,
@@ -8250,12 +8584,12 @@ const create_ai_agent_image = async function (req, job_id, headers) {
   const tempOutputPath = path.join(tempDir, `output_${uniqueId}.png`);
 
   const { app_id, uid, ai_agent_id, tags } = req;
-  const account_profile_info = await get_active_account_profile_info(uid);
+  const account_profile_info = req.account_profile_info || (await get_active_account_profile_info(uid));
   const ai_agent_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, ai_agent_id);
   const account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
 
   // faceless humanoid for business
-  if (account_doc.account_info.account_type === 'business') {
+  if (account_doc.account_info.account_type === 'business' || ai_agent_doc.studio_meta?.force_faceless_agent_image) {
     const prompt = `
       Create a futuristic, faceless humanoid profile portrait with a transparent background.
 
@@ -8290,7 +8624,7 @@ const create_ai_agent_image = async function (req, job_id, headers) {
 
         `;
 
-    const images_arr = await create_and_upload_image_to_drive('studio', 'Progs Thumbnails', ai_agent_id, prompt, 1, uid, app_id, job_id, headers, false, tags, account_profile_info);
+    const images_arr = await create_and_upload_image_to_drive('studio', 'Progs Thumbnails', ai_agent_id, prompt, 1, uid, app_id, job_id, headers, false, tags, account_profile_info, 1024, 1024);
     return { code: 1, data: images_arr[0] };
   }
 
@@ -13538,8 +13872,8 @@ export const get_chat_suggestions = async function (req) {
               ai_agent_doc.reference_doc = reference_doc;
             } else if (ai_agent_doc.studio_meta.installed_from_app_uid) {
               const reference_doc = _.cloneDeep(ai_agent_doc);
-              await get_account_default_project_id(ai_agent_doc.studio_meta.installed_from_app_uid);
-              ai_agent_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, ai_agent_doc.studio_meta.share_item_id);
+              const source_app_id = ai_agent_doc.studio_meta.installed_from_app_id || (await get_account_default_project_id(ai_agent_doc.studio_meta.installed_from_app_uid));
+              ai_agent_doc = await db_module.get_app_couch_doc_native(source_app_id, ai_agent_doc.studio_meta.share_item_id || ai_agent_doc._id);
               ai_agent_doc.reference_doc = reference_doc;
             }
 

package/package.json

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