@xuda.io/ai_module 1.1.5614 → 1.1.5615

package/index.mjs

@@ -2085,6 +2085,10 @@ const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', si
         prompt,
         size,
         n,
+        // Output is downscaled to width×height (default 256²) right below, so a
+        // high-quality 1024² render is wasted. 'low' is indistinguishable at
+        // thumbnail size and 2-8x cheaper. Tunable via _conf.chat_image_quality.
+        quality: _conf.chat_image_quality || 'low',
       });
       report_ai_status(model);
     } catch (err) {
@@ -9475,9 +9479,9 @@ async function restoreFaceWithOpenAI(base64Image, ctx = {}) {
     response = await client.images.edit({
       model,
       image: imageFile,
-      input_fidelity: 'high',
-      quality: 'high',
-      size: 'auto',
+      input_fidelity: 'high', // identity preservation — keep high (don't degrade)
+      quality: _conf.avatar_image_quality || 'low', // 'low' approved 2026-06-02 (A/B vs high/medium); identity held by input_fidelity:high. ~$0.08 vs $0.23 high. Override via _conf.avatar_image_quality.
+      size: _conf.avatar_image_size || '1024x1024', // was 'auto' (could pick 1536 = ~1.5x output tokens); avatars are square
       prompt:
         'Restore this portrait photograph. Remove scratches, dust, grain, noise, faded color, and any age-related damage. Recover natural skin texture, sharpen face details, and balance lighting and color. Preserve the exact same person completely unchanged: same face shape, same eye shape and color, same nose, same mouth, same hairline and hair, same skin tone, same age, same gender, same facial expression, and same clothing. Do not alter, beautify, age, or de-age the person. Output a clean, naturally lit photograph of the same person.',
     });
@@ -14629,3 +14633,557 @@ export const widget_get_messages = async function (req, job_id, headers) {
     return { code: -1, data: err.message || String(err) };
   }
 };
+
+// ============================================================================
+//   Static-website generation pipeline (helpers + orchestrator)
+// ============================================================================
+//
+// pick_image_source     - three-bucket router (Pexels / gpt-image-1 / chatgpt-image-latest)
+// pexels_search         - first consumer of _conf.pexels.api_key
+// estimate_static_website_cost - credit pre-check for create + modify
+// ingest_attachments    - categorize user-uploaded files into the output tree + manifest
+// generate_site_files   - planning prompt + per-page HTML + per-image source + SEO files
+// modify_site_files     - modify-by-prompt over existing file set
+//
+// Image-source bucket order (cheapest -> most expensive): Pexels (free) ->
+// gpt-image-1 (cheap AI) -> chatgpt-image-latest (premium AI). Decision is
+// driven by membership/workspace tier and credit balance so a paid user
+// running low auto-degrades from premium to cheap rather than failing.
+
+const LOW_CREDIT_THRESHOLD = _conf.static_website?.low_credit_threshold ?? 10;
+const HIGH_CREDIT_THRESHOLD = _conf.static_website?.high_credit_threshold ?? 100;
+
+export const pick_image_source = (account_doc, credit_balance) => {
+  const free_mem = (account_doc?.membership_plan || 'free') === 'free';
+  const free_ws = (account_doc?.ai_workspace_plan || 'free_ai_workspace') === 'free_ai_workspace';
+  const credits = Number(credit_balance ?? 0);
+  const paid_tier = !free_mem || !free_ws;
+
+  // Bucket 1: no AI option (fully-free + no credits)
+  if (!paid_tier && credits < LOW_CREDIT_THRESHOLD) return 'pexels';
+  // Bucket 3: premium, only for paid users with a comfortable buffer
+  if (paid_tier && credits >= HIGH_CREDIT_THRESHOLD) return 'chatgpt-image-latest';
+  // Bucket 2: cheaper AI - free users with credits, paid users running low (auto-degrade)
+  return 'gpt-image-1';
+};
+
+export const pexels_search = async (query, n = 1) => {
+  const api_key = _conf.pexels?.api_key;
+  if (!api_key) throw new Error('pexels.api_key not configured');
+  const url = `https://api.pexels.com/v1/search?query=${encodeURIComponent(query)}&per_page=${Math.max(1, Math.min(80, Number(n) || 1))}`;
+  const r = await fetch(url, { headers: { Authorization: api_key } });
+  if (!r.ok) throw new Error(`pexels search failed: ${r.status}`);
+  const j = await r.json();
+  const photos = (j.photos || []).slice(0, n);
+  return Promise.all(
+    photos.map(async (p) => {
+      const img = await fetch(p.src.large || p.src.medium || p.src.original);
+      if (!img.ok) throw new Error(`pexels fetch failed: ${img.status}`);
+      const buf = Buffer.from(await img.arrayBuffer());
+      return {
+        content_b64: buf.toString('base64'),
+        content_type: 'image/jpeg',
+        src_url: p.url,
+        photographer: p.photographer,
+        photographer_url: p.photographer_url,
+      };
+    }),
+  );
+};
+
+// Expected per-tier work for the credit estimator. Real generated count is
+// usually a fraction of the hard cap (page_count_limit in PLAN_OBJ).
+const EXPECTED_STATIC_WEBSITE_WORK = {
+  landing: { pages: 1, imgs_per_page: 2, seo: 0, css: 1 },
+  full: { pages: 8, imgs_per_page: 3, seo: 0, css: 1 },
+  seo: { pages: 25, imgs_per_page: 3, seo: 2, css: 1 },
+  enterprise: { pages: 100, imgs_per_page: 3, seo: 2, css: 1 },
+};
+
+const _image_price = (image_source) => {
+  if (image_source === 'pexels') return 0;
+  const m = _conf.ai_models?.[image_source];
+  return m?.price ?? Math.max(m?.input ?? 0, m?.output ?? 0) ?? 5;
+};
+
+const _text_price = () => {
+  const k = _conf.default_ai_model || 'gpt-5.4-mini';
+  const m = _conf.ai_models?.[k];
+  return m?.price ?? 1;
+};
+
+export const estimate_static_website_cost = (req) => {
+  const plan_tier = req?.plan_tier;
+  const image_source = req?.image_source || 'gpt-image-1';
+  const mode = req?.mode || 'create';
+  const current_page_count = Number(req?.current_page_count || 0);
+
+  const W = EXPECTED_STATIC_WEBSITE_WORK[plan_tier] || EXPECTED_STATIC_WEBSITE_WORK.landing;
+  const pages =
+    mode === 'modify'
+      ? Math.max(1, Math.ceil(current_page_count * 0.3)) // modify touches ~30% by default
+      : W.pages;
+  const text_calls = 1 /* site plan */ + W.css + pages /* per-page HTML */ + W.seo;
+  const image_calls = pages * W.imgs_per_page;
+
+  const text_unit = _text_price();
+  const image_unit = _image_price(image_source);
+  const credits_needed = text_calls * text_unit + image_calls * image_unit;
+
+  return {
+    credits_needed,
+    breakdown: { text_calls, text_unit, image_calls, image_unit, pages, mode },
+    image_source,
+  };
+};
+
+// ── Attachment ingestion ────────────────────────────────────────────────
+//
+// Shape: [{ filename, mime_type, drive_path? | content_b64? | url? }]
+// At least one source field must be present. Files land in the deployed site
+// at a stable /uploads/{img,docs,text,data,files}/{slug} path so the LLM can
+// reference them by URL in generated HTML.
+
+const _categorize_attachment = (att) => {
+  const mt = (att?.mime_type || '').toLowerCase();
+  if (mt.startsWith('image/')) return 'image';
+  if (mt === 'application/pdf') return 'pdf';
+  if (mt === 'text/csv' || mt === 'application/vnd.ms-excel') return 'data';
+  if (mt === 'application/json' || mt === 'text/markdown' || mt.startsWith('text/')) return 'text';
+  return 'binary';
+};
+
+const _load_attachment_bytes = async (att) => {
+  if (att.content_b64) return Buffer.from(att.content_b64, 'base64');
+  if (att.drive_path) {
+    const abs = path.join(_conf.studio_drive_path, att.drive_path);
+    return await readFile(abs);
+  }
+  if (att.url) {
+    const r = await fetch(att.url);
+    if (!r.ok) throw new Error(`attachment fetch ${att.url}: ${r.status}`);
+    return Buffer.from(await r.arrayBuffer());
+  }
+  throw new Error(`attachment ${att.filename} has no source (drive_path | content_b64 | url)`);
+};
+
+export const ingest_attachments = async (attachments = []) => {
+  const out = { manifest: [], file_entries: [], text_corpus: [] };
+  for (const att of attachments) {
+    if (!att || !att.filename) continue;
+    const kind = _categorize_attachment(att);
+    let bytes;
+    try {
+      bytes = await _load_attachment_bytes(att);
+    } catch (err) {
+      console.error('[ingest_attachments] skip', att.filename, err.message);
+      continue;
+    }
+    const slug = String(att.filename)
+      .replace(/[^a-z0-9.-]/gi, '_')
+      .toLowerCase();
+    let public_path;
+    if (kind === 'image') public_path = `/uploads/img/${slug}`;
+    else if (kind === 'pdf') public_path = `/uploads/docs/${slug}`;
+    else if (kind === 'text') public_path = `/uploads/text/${slug}`;
+    else if (kind === 'data') public_path = `/uploads/data/${slug}`;
+    else public_path = `/uploads/files/${slug}`;
+
+    out.file_entries.push({
+      path: public_path,
+      content_b64: bytes.toString('base64'),
+      content_type: att.mime_type || 'application/octet-stream',
+    });
+
+    const manifest_entry = { filename: att.filename, kind, public_path };
+    if (kind === 'text' || kind === 'data') {
+      const text = bytes.toString('utf8').slice(0, 8000);
+      manifest_entry.excerpt = text;
+      out.text_corpus.push({ filename: att.filename, text });
+    }
+    if (kind === 'image') {
+      manifest_entry.usage = `Embed via <img src="${public_path}" alt="..."> on relevant pages.`;
+    }
+    out.manifest.push(manifest_entry);
+  }
+  return out;
+};
+
+// ── Generation orchestrator ─────────────────────────────────────────────
+//
+// generate_site_files runs the prompt -> plan -> pages -> images -> SEO chain.
+// Returns a flat [{ path, content_b64, content_type }] list ready for
+// domains_module.deploy_site.
+
+const _safe_json_parse = (s) => {
+  if (!s || typeof s !== 'string') return null;
+  // The LLM sometimes wraps JSON in ```json fences despite instructions.
+  const cleaned = s
+    .trim()
+    .replace(/^```(?:json)?\s*/i, '')
+    .replace(/\s*```\s*$/i, '');
+  try {
+    return JSON.parse(cleaned);
+  } catch (_) {
+    return null;
+  }
+};
+
+const _chat = async (uid, prompt, account_profile_info, metadata) => {
+  const ret = await submit_chat_gpt_prompt({
+    uid,
+    prompt,
+    model: _conf.default_ai_model,
+    metadata: metadata || {},
+    account_profile_info,
+  });
+  if (ret.code < 0) throw new Error(`LLM call failed: ${ret.data}`);
+  return ret.data || '';
+};
+
+const _site_planning_prompt = (user_prompt, attachments_manifest, plan_tier, page_count_limit) => {
+  const W = EXPECTED_STATIC_WEBSITE_WORK[plan_tier] || EXPECTED_STATIC_WEBSITE_WORK.landing;
+  const default_pages = Math.min(W.pages, page_count_limit);
+  return `You are planning a static website. Output STRICT JSON only, no prose, no markdown fences.
+
+User brief:
+${user_prompt}
+
+User-uploaded files (manifest). The generated pages MUST use these where appropriate: embed images via <img src="$public_path">, quote / paraphrase text excerpts where they fit, link to PDFs, structure pages around data when relevant.
+${JSON.stringify(attachments_manifest, null, 2)}
+
+Hard rules:
+- Hosting tier: ${plan_tier}. Maximum ${page_count_limit} pages total. Aim for ${default_pages} pages unless the brief clearly implies more.
+- Each page has a slug (kebab-case path component, "" for home), title, and an ordered list of sections.
+- Each page also lists image_specs: image slots needed on that page. For each slot, decide source: 'attachment' (when an uploaded image fits) OR 'generate' (when one must be created).
+- For 'generate' slots, write a concise visual prompt AND a Pexels-friendly query string.
+- For 'attachment' slots, set attachment_path to one of the public_paths from the manifest.
+- style_directive is one paragraph describing the desired visual style (palette, typography, density) used to generate the global stylesheet.
+
+Schema:
+{
+  "pages": [
+    {
+      "slug": "string (empty for home)",
+      "title": "string",
+      "sections": [{"kind": "prose|image|quote|data_table|callout", "...": "..."}],
+      "image_specs": [
+        {"slot": "kebab-slug", "source": "generate|attachment", "prompt": "...", "query": "...", "attachment_path": "/uploads/...", "aspect": "16/10|1/1|3/2"}
+      ]
+    }
+  ],
+  "style_directive": "string"
+}
+
+Respond with ONLY the JSON object.`;
+};
+
+const _page_html_prompt = (page, style_directive, attachments_manifest) => `Generate a single static HTML page. Output ONLY the HTML, no markdown fences, no commentary.
+
+Page brief:
+${JSON.stringify(page, null, 2)}
+
+Global style directive (matches /style.css that's already written):
+${style_directive}
+
+Attachments available (use these public_paths verbatim when referenced):
+${JSON.stringify(attachments_manifest, null, 2)}
+
+Hard rules:
+- DOCTYPE html, lang="en", responsive viewport meta.
+- Link to /style.css.
+- Reference images from /img/{slot}.{ext} for 'generate' slots and from their public_path for 'attachment' slots, exactly as listed in image_specs.
+- Semantic HTML5 (header, main, section, footer). No inline styles unless absolutely necessary.
+- No external CDNs, no JavaScript.
+- Title from page.title.
+
+Respond with ONLY the raw HTML document.`;
+
+const _css_prompt = (style_directive, plan_tier) => `Generate ONE global stylesheet for a ${plan_tier}-tier static website. Output ONLY the CSS, no markdown fences, no commentary.
+
+Style directive:
+${style_directive}
+
+Hard rules:
+- Modern CSS only (no preprocessors). Use CSS variables for palette.
+- Responsive: mobile-first, breakpoints at 640px and 980px.
+- Typography: choose a serif heading + sans-serif body OR all sans, consistent with the directive.
+- Include base resets, layout containers, header, footer, basic image styling (max-width 100%, rounded), button styles.
+- Keep under 6 KB.
+
+Respond with ONLY the raw CSS text.`;
+
+const _sitemap_xml = (pages, hostname) => {
+  const base = `https://${hostname}`;
+  const urls = pages
+    .map((p) => {
+      const loc = p.slug ? `${base}/${p.slug}/` : `${base}/`;
+      return `  <url><loc>${loc}</loc></url>`;
+    })
+    .join('\n');
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls}\n</urlset>\n`;
+};
+
+const _robots_txt = (hostname) => `User-agent: *\nAllow: /\nSitemap: https://${hostname}/sitemap.xml\n`;
+
+// Picks an extension for a generated image filename from its content-type.
+const _image_ext = (content_type) => {
+  if (!content_type) return 'png';
+  if (/webp/i.test(content_type)) return 'webp';
+  if (/jpe?g/i.test(content_type)) return 'jpg';
+  if (/png/i.test(content_type)) return 'png';
+  if (/svg/i.test(content_type)) return 'svg';
+  return 'png';
+};
+
+export const generate_site_files = async (req) => {
+  try {
+    const { uid, prompt, attachments, plan_tier, page_count_limit, image_source, account_profile_info, hostname = 'sites.xuda.io' } = req;
+    if (!uid || !prompt) return { code: -1, data: 'uid + prompt required' };
+    if (!plan_tier) return { code: -1, data: 'plan_tier required' };
+
+    // 1. Ingest attachments (copies them into the output file list verbatim)
+    const ingestion = await ingest_attachments(attachments || []);
+
+    // 2. Plan the site
+    const plan_text = await _chat(uid, _site_planning_prompt(prompt, ingestion.manifest, plan_tier, page_count_limit), account_profile_info, { stage: 'static_website_plan', plan_tier });
+    const plan = _safe_json_parse(plan_text);
+    if (!plan || !Array.isArray(plan.pages) || !plan.pages.length) {
+      return { code: -2, data: 'planning JSON malformed', plan_text };
+    }
+
+    // 3. Hard-cap page count
+    plan.pages = plan.pages.slice(0, Math.max(1, Math.min(page_count_limit, plan.pages.length)));
+
+    // 4. Global CSS
+    const css = await _chat(uid, _css_prompt(plan.style_directive || '', plan_tier), account_profile_info, { stage: 'static_website_css', plan_tier });
+
+    // 5. Per-page HTML
+    const html_files = [];
+    for (const page of plan.pages) {
+      const html = await _chat(uid, _page_html_prompt(page, plan.style_directive || '', ingestion.manifest), account_profile_info, { stage: 'static_website_page', plan_tier, slug: page.slug || '' });
+      const rel = page.slug ? `/${page.slug}/index.html` : '/index.html';
+      html_files.push({
+        path: rel,
+        content_b64: Buffer.from(html, 'utf8').toString('base64'),
+        content_type: 'text/html',
+      });
+    }
+
+    // 6. Per-image generation
+    const image_files = [];
+    for (const page of plan.pages) {
+      const specs = Array.isArray(page.image_specs) ? page.image_specs : [];
+      for (const spec of specs) {
+        try {
+          if (spec.source === 'attachment') {
+            // already in ingestion.file_entries — nothing to add
+            continue;
+          }
+          if (image_source === 'pexels') {
+            const [img] = await pexels_search(spec.query || spec.prompt || page.title, 1);
+            if (!img) continue;
+            image_files.push({
+              path: `/img/${spec.slot}.jpg`,
+              content_b64: img.content_b64,
+              content_type: 'image/jpeg',
+            });
+          } else {
+            const b64 = await create_image(
+              uid,
+              spec.prompt || spec.query || page.title,
+              image_source, // 'gpt-image-1' | 'chatgpt-image-latest'
+              '1024x1024',
+              1,
+              1024,
+              1024, // full-resolution output
+              { kind: 'static_website', slot: spec.slot },
+              account_profile_info,
+            );
+            if (!b64) continue;
+            image_files.push({
+              path: `/img/${spec.slot}.png`,
+              content_b64: b64,
+              content_type: 'image/png',
+            });
+          }
+        } catch (err) {
+          console.error('[generate_site_files] image fail', spec.slot, err.message);
+        }
+      }
+    }
+
+    // 7. SEO files (seo + enterprise tiers only)
+    const seo_files = [];
+    if (plan_tier === 'seo' || plan_tier === 'enterprise') {
+      seo_files.push({
+        path: '/sitemap.xml',
+        content_b64: Buffer.from(_sitemap_xml(plan.pages, hostname), 'utf8').toString('base64'),
+        content_type: 'application/xml',
+      });
+      seo_files.push({
+        path: '/robots.txt',
+        content_b64: Buffer.from(_robots_txt(hostname), 'utf8').toString('base64'),
+        content_type: 'text/plain',
+      });
+    }
+
+    // 8. Compose final flat file list
+    const css_file = {
+      path: '/style.css',
+      content_b64: Buffer.from(css, 'utf8').toString('base64'),
+      content_type: 'text/css',
+    };
+    const files = [css_file, ...html_files, ...image_files, ...seo_files, ...ingestion.file_entries];
+
+    return {
+      code: 1,
+      data: {
+        files,
+        plan,
+        manifest: ingestion.manifest,
+        stats: {
+          page_count: plan.pages.length,
+          image_count: image_files.length,
+          attachment_count: ingestion.file_entries.length,
+        },
+      },
+    };
+  } catch (err) {
+    return { code: -400, data: err.message };
+  }
+};
+
+// ── Modify orchestrator ────────────────────────────────────────────────
+//
+// Loads current files, asks LLM what to change, writes back only the deltas.
+// Image source stays pinned to whatever was chosen at creation - modify does
+// NOT silently upgrade Pexels -> AI (that would surprise free users).
+
+const _modify_prompt = (user_prompt, current_files_index, attachments_manifest) => `You are editing an existing static website. Output STRICT JSON only, no prose, no markdown fences.
+
+User request:
+${user_prompt}
+
+Current file index (path + size + content-type — NOT full content; ask the user to re-attach if you need to read a file's body):
+${JSON.stringify(current_files_index, null, 2)}
+
+New attachments uploaded with this request:
+${JSON.stringify(attachments_manifest, null, 2)}
+
+For each change you want to make, emit one entry in "changes":
+  { "path": "/index.html", "action": "replace", "new_content": "...full new file content..." }
+  { "path": "/about/index.html", "action": "create", "new_content": "..." }
+  { "path": "/old-page/index.html", "action": "delete" }
+
+Image regeneration: emit { "image_change": { "path": "/img/hero.png", "new_prompt": "..." } } and the orchestrator will re-render via the locked image source.
+
+Hard rules:
+- Touch only files you actually need to change. Do NOT rewrite the whole site.
+- new_content for HTML files: full document, DOCTYPE through </html>. Link /style.css unchanged unless explicitly told to restyle.
+- Do NOT change file paths for unchanged pages.
+
+Schema:
+{ "changes": [...], "summary": "one sentence" }
+
+Respond with ONLY the JSON object.`;
+
+export const modify_site_files = async (req) => {
+  try {
+    const { uid, current_files, prompt, attachments, plan_tier, image_source, account_profile_info } = req;
+    if (!uid || !prompt) return { code: -1, data: 'uid + prompt required' };
+    if (!Array.isArray(current_files) || !current_files.length) return { code: -1, data: 'current_files required' };
+
+    const ingestion = await ingest_attachments(attachments || []);
+    const index = current_files.map((f) => ({
+      path: f.path,
+      content_type: f.content_type,
+      size_b64: (f.content_b64 || '').length,
+    }));
+
+    const diff_text = await _chat(uid, _modify_prompt(prompt, index, ingestion.manifest), account_profile_info, { stage: 'static_website_modify', plan_tier });
+    const diff = _safe_json_parse(diff_text);
+    if (!diff || !Array.isArray(diff.changes)) {
+      return { code: -2, data: 'modify JSON malformed', diff_text };
+    }
+
+    const changed_paths = [];
+    const updated_files = [...current_files];
+
+    const _find = (p) => updated_files.findIndex((f) => f.path === p);
+
+    for (const ch of diff.changes) {
+      // Re-rendered image
+      if (ch.image_change && ch.image_change.path && ch.image_change.new_prompt) {
+        const ip = ch.image_change.path;
+        try {
+          if (image_source === 'pexels') {
+            const [img] = await pexels_search(ch.image_change.new_prompt, 1);
+            if (img) {
+              const entry = { path: ip, content_b64: img.content_b64, content_type: 'image/jpeg' };
+              const idx = _find(ip);
+              if (idx >= 0) updated_files[idx] = entry;
+              else updated_files.push(entry);
+              changed_paths.push(ip);
+            }
+          } else {
+            const b64 = await create_image(uid, ch.image_change.new_prompt, image_source, '1024x1024', 1, 1024, 1024, { kind: 'static_website_modify' }, account_profile_info);
+            if (b64) {
+              const entry = { path: ip, content_b64: b64, content_type: 'image/png' };
+              const idx = _find(ip);
+              if (idx >= 0) updated_files[idx] = entry;
+              else updated_files.push(entry);
+              changed_paths.push(ip);
+            }
+          }
+        } catch (err) {
+          console.error('[modify_site_files] image regen fail', ip, err.message);
+        }
+        continue;
+      }
+
+      if (!ch.path || !ch.action) continue;
+      const idx = _find(ch.path);
+
+      if (ch.action === 'delete') {
+        if (idx >= 0) {
+          updated_files.splice(idx, 1);
+          changed_paths.push(ch.path);
+        }
+        continue;
+      }
+
+      if ((ch.action === 'replace' || ch.action === 'create') && typeof ch.new_content === 'string') {
+        const ext = (ch.path.match(/\.([a-z0-9]+)$/i) || [, ''])[1].toLowerCase();
+        const content_type = ext === 'html' ? 'text/html' : ext === 'css' ? 'text/css' : ext === 'js' ? 'application/javascript' : ext === 'json' ? 'application/json' : ext === 'xml' ? 'application/xml' : ext === 'txt' ? 'text/plain' : 'text/plain';
+        const entry = {
+          path: ch.path,
+          content_b64: Buffer.from(ch.new_content, 'utf8').toString('base64'),
+          content_type,
+        };
+        if (idx >= 0) updated_files[idx] = entry;
+        else updated_files.push(entry);
+        changed_paths.push(ch.path);
+      }
+    }
+
+    // Any new attachments uploaded this round join the file set verbatim.
+    for (const entry of ingestion.file_entries) {
+      const idx = _find(entry.path);
+      if (idx >= 0) updated_files[idx] = entry;
+      else updated_files.push(entry);
+      changed_paths.push(entry.path);
+    }
+
+    return {
+      code: 1,
+      data: {
+        updated_files,
+        changed_paths,
+        summary: diff.summary || '',
+      },
+    };
+  } catch (err) {
+    return { code: -400, data: err.message };
+  }
+};

package/index_ms.mjs

@@ -17,6 +17,30 @@
 
  
 
+export const pick_image_source = async function (...args) {
+  return await broker.send_to_queue("pick_image_source", ...args);
+};
+
+export const pexels_search = async function (...args) {
+  return await broker.send_to_queue("pexels_search", ...args);
+};
+
+export const estimate_static_website_cost = async function (...args) {
+  return await broker.send_to_queue("estimate_static_website_cost", ...args);
+};
+
+export const ingest_attachments = async function (...args) {
+  return await broker.send_to_queue("ingest_attachments", ...args);
+};
+
+export const generate_site_files = async function (...args) {
+  return await broker.send_to_queue("generate_site_files", ...args);
+};
+
+export const modify_site_files = async function (...args) {
+  return await broker.send_to_queue("modify_site_files", ...args);
+};
+
 export const execute_codex_request = async function (...args) {
   return await broker.send_to_queue("execute_codex_request", ...args);
 };
@@ -193,6 +217,10 @@ export const is_spam_email = async function (...args) {
   return await broker.send_to_queue("is_spam_email", ...args);
 };
 
+export const marketplace_review_item = async function (...args) {
+  return await broker.send_to_queue("marketplace_review_item", ...args);
+};
+
 export const is_business_contact = async function (...args) {
   return await broker.send_to_queue("is_business_contact", ...args);
 };
@@ -260,7 +288,3 @@ export const widget_send_message = async function (...args) {
 export const widget_get_messages = async function (...args) {
   return await broker.send_to_queue("widget_get_messages", ...args);
 };
-
-export const marketplace_review_item = async function (...args) {
-  return await broker.send_to_queue("marketplace_review_item", ...args);
-};

package/index_msa.mjs

@@ -17,6 +17,30 @@
 
  
 
+export const pick_image_source =  function (...args) {
+   broker.send_to_queue_async("pick_image_source", ...args);
+};
+
+export const pexels_search =  function (...args) {
+   broker.send_to_queue_async("pexels_search", ...args);
+};
+
+export const estimate_static_website_cost =  function (...args) {
+   broker.send_to_queue_async("estimate_static_website_cost", ...args);
+};
+
+export const ingest_attachments =  function (...args) {
+   broker.send_to_queue_async("ingest_attachments", ...args);
+};
+
+export const generate_site_files =  function (...args) {
+   broker.send_to_queue_async("generate_site_files", ...args);
+};
+
+export const modify_site_files =  function (...args) {
+   broker.send_to_queue_async("modify_site_files", ...args);
+};
+
 export const execute_codex_request =  function (...args) {
    broker.send_to_queue_async("execute_codex_request", ...args);
 };
@@ -193,6 +217,10 @@ export const is_spam_email =  function (...args) {
    broker.send_to_queue_async("is_spam_email", ...args);
 };
 
+export const marketplace_review_item =  function (...args) {
+   broker.send_to_queue_async("marketplace_review_item", ...args);
+};
+
 export const is_business_contact =  function (...args) {
    broker.send_to_queue_async("is_business_contact", ...args);
 };

package/package.json

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