@xuda.io/ai_module 1.1.5617 → 1.1.5619

package/index.js

@@ -0,0 +1,3751 @@
+console.log('AI Module loaded...');
+
+import { z } from 'zod';
+import fs from 'fs';
+import * as path from 'path';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import sharp from 'sharp';
+
+import puppeteer from 'puppeteer-extra';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+import youtubedl from 'youtube-dl-exec';
+
+import crypto from 'node:crypto';
+
+// import { VM } from 'vm2';
+import { NodeVM, VMScript } from 'vm2';
+
+puppeteer.use(StealthPlugin());
+import process from 'process';
+import { File } from 'node:buffer'; // Node 20+
+const { readFile, unlink, writeFile } = fs.promises;
+
+// global._common = JSON.parse(await fs.readFile(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.js'), 'utf-8'));
+global._conf = JSON.parse(await readFile(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), 'utf-8'));
+
+const module_path = path.join(process.env.XUDA_HOME, 'cpi') + (!_conf.is_debug ? '/node_modules/@xuda.io' : '');
+const runtime_modules_path = path.join(process.env.XUDA_HOME, 'dist', 'runtime', 'js', 'modules');
+
+import { Agent, Runner, tool, setDefaultOpenAIKey, RunContext, fileSearchTool, webSearchTool, hostedMcpTool } from '@openai/agents';
+import OpenAI, { toFile } from 'openai';
+
+setDefaultOpenAIKey(_conf.OPENAI_API_KEY);
+
+import _ from 'lodash';
+import JSON5 from 'json5';
+import UglifyJS from 'uglify-js';
+
+global._ = _;
+
+const { get_xuda_couch } = await import(`${module_path}/db_module/index.es.mjs`);
+const { createDoc, valid_menuType } = await import(`${runtime_modules_path}/xuda-studio-doc-utils.mjs`);
+const { xudaPrase } = await import(`${runtime_modules_path}/xuda-cli-plugin-html-parser-module.esm.mjs`);
+const { cast } = await import(`${runtime_modules_path}/xuda-get-cast-util-module.mjs`);
+
+const { init, check, check_structure, get_zod_schema } = await import(`${runtime_modules_path}/xuda-studio-checker.mjs`);
+
+let client;
+try {
+  client = new OpenAI({
+    apiKey: _conf.OPENAI_API_KEY,
+  });
+
+  console.log('chat-gpt client initiated..OK');
+} catch (err) {
+  console.error(err);
+}
+const model = 'gpt-5-nano'; //'gpt-5'; // 'ft:gpt-4o-2024-08-06:xuda-io:xuda:CC4aHCsz';
+
+var studio_units = {};
+
+const init_studio_units = async function () {
+  try {
+    const db = get_xuda_couch('xuda_website');
+
+    const ret = await db.find({ selector: { type: 'app-builder', docType: 'feature' } });
+    for (const doc of ret.docs) {
+      studio_units[doc._id.replace('-', '_')] = doc;
+    }
+    // console.log(studio_units);
+  } catch (err) {
+    console.error(err);
+  }
+};
+await init_studio_units();
+
+const get_studio_table_info_tool = tool({
+  name: 'Get studio table info',
+  description: 'Get the table doc by table_name',
+  parameters: z.object({
+    table: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const { table } = e;
+    const { app_id, uid } = RunContext.context;
+    debugger;
+    if (!table) throw new Error('got null in the table parameter');
+
+    try {
+      const project_db = await get_project_db(app_id);
+      let tables = await project_db.view('xuda', 'studio_docs_by_type', { key: 'table' });
+      let response = '';
+
+      for (const doc of tables.rows) {
+        const _menuName = doc?.value?.properties?.menuName?.toLowerCase();
+        if (_menuName && _menuName === table.toLowerCase()) {
+          try {
+            response = await project_db.get(doc.id);
+            break;
+          } catch (error) {
+            throw new Error(`table doc ${doc.id} not found`);
+          }
+        }
+      }
+
+      if (_.isEmpty(response)) {
+        for (const doc of tables.rows) {
+          const _menuName = doc?.value?.properties?.menuName?.toLowerCase();
+          if (_menuName && (_menuName.includes(table.toLowerCase()) || _menuName.includes(table.replace('_', ' ').toLowerCase()))) {
+            response += `could not found ${table} but found ${_menuName} instead. `;
+          }
+        }
+      }
+
+      if (_.isEmpty(response)) {
+        throw new Error(`table ${table} not found`);
+      }
+
+      return response;
+    } catch (err) {
+      return err.message;
+    }
+  },
+});
+
+const save_doc_tool = tool({
+  name: 'Save Doc',
+  description: 'Save doc (such as table,component,set_data,get_data,alert,batch,globals,route,database) to the project to db',
+  parameters: z.object({
+    // app_id: z.string(),
+    doc: z.string(), // z.object({}), // _id
+  }),
+  async execute(e, RunContext) {
+    const { doc } = e;
+    const { app_id, uid } = RunContext.context;
+    try {
+      const doc_obj = JSON5.parse(doc);
+      const project_db = await get_project_db(app_id);
+      const result = await project_db.insert(doc_obj);
+      console.log('save_doc_tool >>>> ', result);
+      return result;
+    } catch (err) {
+      console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const delete_doc_tool = tool({
+  name: 'Delete Doc',
+  description: 'Delete doc using _id',
+  parameters: z.object({
+    _id: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const { _id } = e;
+    const { app_id, uid } = RunContext.context;
+    try {
+      const project_db = await get_project_db(app_id);
+      let doc = await project_db.get(_id);
+      doc.stat = 4;
+      doc.ts = Date.now();
+      const result = await project_db.insert(doc);
+      console.log('delete doc >>>> ', result);
+      return result;
+    } catch (err) {
+      console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const fetch_data_tool = tool({
+  name: 'Fetch Table Data',
+  description: 'this tool perform query find base on couchdb mango syntax',
+  parameters: z.object({
+    query: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const { query } = e;
+    const { app_id, uid, table_id } = RunContext.context;
+    try {
+      const query_obj = JSON5.parse(query);
+      console.log('query_obj', query_obj);
+      const project_db = await get_project_db(app_id);
+      let table_doc;
+      try {
+        table_doc = await project_db.get(table_id);
+      } catch (error) {
+        throw new Error(`table doc ${table_id} not found`);
+      }
+
+      function validateQueryAgainstTable(query, tableFields) {
+        const errors = [];
+        const validFieldIds = new Set((tableFields || []).map((f) => f.data?.field_id).filter(Boolean));
+
+        const selector = query.selector || {};
+        if (selector.docType !== 'database') errors.push('selector.docType must be "database"');
+        if (selector.stat !== 3) errors.push('selector.stat must be 3');
+
+        const validate = (path, ctx) => {
+          if (!path.startsWith('udfData.data.')) {
+            errors.push(`Invalid field path in ${ctx}: "${path}" — must start with "udfData.data."`);
+            return null;
+          }
+          const id = path.slice(13);
+          if (!validFieldIds.has(id)) {
+            errors.push(`Field "${path}" not defined in table`);
+          }
+          return id;
+        };
+
+        const walk = (obj, p = '') => {
+          if (!obj || typeof obj !== 'object') return;
+          for (const [k, v] of Object.entries(obj)) {
+            const fp = p ? `${p}.${k}` : k;
+            if (!k.startsWith('$') && fp.startsWith('udfData.data.')) validate(fp, 'selector');
+            if (v && typeof v === 'object') Array.isArray(v) ? v.forEach((i) => walk(i, fp)) : walk(v, fp);
+          }
+        };
+
+        walk(selector);
+        (query.fields || []).forEach((f) => validate(f, 'fields'));
+        (query.sort || []).forEach((s) => Object.entries(s).forEach(([f]) => validate(f, 'sort')));
+
+        return { isValid: errors.length === 0, errors };
+      }
+
+      const validateQuery_result = validateQueryAgainstTable(query_obj, table_doc.tableFields);
+      debugger;
+      if (!validateQuery_result.isValid) {
+        // console.error('Validation failed:', validateQuery_result.errors);
+        throw new Error(`Validation failed: ${JSON.stringify(validateQuery_result.errors)}`);
+      }
+
+      const result = await project_db.find(query_obj);
+      console.log('Fetch Table Data >>>> ', result);
+      return result;
+    } catch (err) {
+      // console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const create_table_management_tool = tool({
+  name: 'Create Table Management Program',
+  description: 'this tool create table management program',
+  parameters: z.object({}),
+  async execute(e, RunContext) {
+    const { app_id, uid, table_id, userName } = RunContext.context;
+    try {
+      const project_db = await get_project_db(app_id);
+      let table_doc;
+      try {
+        table_doc = await project_db.get(table_id);
+      } catch (error) {
+        throw new Error(`table doc ${table_id} not found`);
+      }
+
+      const menuType = 'component';
+      const parentId = 'programs';
+      const checkedInUserName = userName;
+      const name = `${table_doc.properties.menuName} ${table_doc.properties.menuName.includes('table') ? '' : 'table '}Management Program`;
+      const doc = createDoc({ uid, properties: { menuType, menuName: name, menuTitle: name }, checkedInUserName, app_id, parentId });
+
+      const progUi = [
+        {
+          id: 'root',
+          type: 'element',
+          tagName: 'xu-multi-view',
+          attributes: {},
+          children: [
+            {
+              type: 'element',
+              tagName: 'div',
+              attributes: {},
+              children: [
+                {
+                  type: 'element',
+                  tagName: 'xu-widget',
+                  attributes: {
+                    'xu-widget': '@xuda.io/xuda-widget-plugin-ag-grid',
+                    'xu-method': '_default',
+                  },
+                  children: [],
+                  id: `node-${crypto.randomUUID()}`,
+                  path: [0, 0, 0],
+                  $folded: false,
+                  code: '<xu-widget xu-widget="@xuda.io/xuda-widget-plugin-ag-grid" xu-method="_default"></xu-widget>',
+                  editCode: false,
+                  $childrenClass: 'active',
+                  $nodeBackClass: 'selected-tree rounded-lg',
+                },
+              ],
+              id: `node-${crypto.randomUUID()}`,
+              path: [0, 0],
+            },
+          ],
+          path: [0],
+          $folded: false,
+        },
+      ];
+
+      const progDataSource = {
+        dataSourceType: 'table',
+        dataSourceFilterModelType: 'index',
+        dataSourceSort: 'asc',
+        dataSourceTableId: table_id,
+      };
+
+      doc.studio_meta.miniApp = true;
+      doc.progUi = progUi;
+      doc.progDataSource = progDataSource;
+      doc.progFields = [];
+
+      for (const field of table_doc.tableFields || []) {
+        const field_id = field.data.field_id;
+        const fieldType = field.props.fieldType;
+
+        doc.progFields.push({
+          id: Date.now(),
+          data: {
+            type: 'table',
+            field_id,
+          },
+          props: {
+            fieldType,
+            propExpressions: {},
+          },
+          workflow: [],
+        });
+      }
+
+      const result = await project_db.insert(doc);
+
+      update_thumbnail('mini_app', doc, uid);
+
+      console.log('Create Table Management Component >>>> ', result);
+      return result;
+    } catch (err) {
+      // console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const create_landing_page_tool = tool({
+  name: 'Create Landing Page Program',
+  description: 'this tool create landing page by subject',
+  parameters: z.object({ subject: z.string().describe('describe the landing page in short') }),
+  async execute(e, RunContext) {
+    const { subject } = e;
+    const { app_id, uid, table_id, userName, app_obj, account_info } = RunContext.context;
+    try {
+      const project_db = await get_project_db(app_id);
+      let table_doc;
+      try {
+        table_doc = await project_db.get(table_id);
+      } catch (error) {
+        throw new Error(`table doc ${table_id} not found`);
+      }
+      debugger;
+      const tableIndexObj = table_doc?.tableIndexes?.[0];
+
+      if (_.isEmpty(tableIndexObj)) {
+        throw new Error(`table have at least one index`);
+      }
+      const indexSegmentKey = tableIndexObj?.data?.keys?.[0];
+
+      if (!indexSegmentKey) {
+        throw new Error(`key segment is empty for the main index`);
+      }
+
+      const dataSourceIndexId = tableIndexObj?.id;
+
+      if (!dataSourceIndexId) {
+        throw new Error(`table have at least one index id`);
+      }
+
+      const title_ret = await submit_chat_gpt_prompt({
+        prompt: `create title for ${subject} return 5 words result maximum text only without options `,
+        model: 'gpt-5-nano',
+      });
+
+      const menuType = 'component';
+      const parentId = 'programs';
+      const checkedInUserName = userName;
+      const name = `${title_ret.data} Landing Page`;
+      const properties = { menuType, menuName: name, menuTitle: name, rwMode: 'U', uiFramework: '@xuda.io/xuda-framework-plugin-tailwind', renderType: 'form', allowCreate: true };
+      const doc = createDoc({ uid, properties, checkedInUserName, app_id, parentId });
+
+      const progDataSource = {
+        dataSourceType: 'table',
+        dataSourceFilterModelType: 'index',
+        dataSourceSort: 'asc',
+        dataSourceTableId: table_id,
+        dataSourceIndexId,
+        dataSourceIndexesObj: {
+          [dataSourceIndexId]: {
+            [indexSegmentKey]: {
+              from: 'Date.now()',
+              locate_from: '',
+              locate_to: '',
+              to: 'Date.now()',
+              key: indexSegmentKey,
+            },
+          },
+        },
+      };
+
+      doc.studio_meta.miniApp = true;
+
+      doc.progDataSource = progDataSource;
+      doc.progFields = [];
+
+      let contactFormFields = [];
+
+      for (const field of table_doc.tableFields || []) {
+        const field_id = field.data.field_id;
+        const fieldType = field.props.fieldType;
+        contactFormFields.push({ field_id, fieldType });
+        doc.progFields.push({
+          id: Date.now(),
+          data: {
+            type: 'table',
+            field_id,
+          },
+          props: {
+            fieldType,
+            propExpressions: {},
+          },
+          workflow: [],
+        });
+      }
+
+      const html_ret = await submit_chat_gpt_prompt({
+        prompt: `Create a single-page landing layout with a Tailwind-styled contact form (fields: ${JSON.stringify(contactFormFields)}, subject: ${subject}). No navigation. Return only the <body> content. contact info:${JSON.stringify(account_info)} ${JSON.stringify(app_obj.app_general_prop)}`,
+        model: 'gpt-5-nano',
+      });
+      debugger;
+      const progUi = xudaPrase(html_ret.data);
+      doc.progUi = progUi;
+      doc.html = html_ret.data;
+
+      const result = await project_db.insert(doc);
+
+      update_thumbnail('mini_app', doc, uid);
+
+      console.log('Create Landing Page >>>> ', result);
+      return result;
+    } catch (err) {
+      // console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const create_index_tool = tool({
+  name: 'Create Index',
+  description: 'this tool creating index',
+  parameters: z.object({
+    index: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const { index } = e;
+    const { app_id, uid } = RunContext.context;
+    try {
+      debugger;
+      const index_obj = JSON5.parse(index);
+      console.log('Create Index', index_obj);
+      const project_db = await get_project_db(app_id);
+      console.log('Create Index >>>> ', index);
+      const result = await project_db.createIndex(index_obj);
+
+      return result;
+    } catch (err) {
+      console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const get_studio_table_info_by_table_id_tool = tool({
+  name: 'Get Studio Table Info',
+  description: 'Get the table doc by table_id',
+  parameters: z.object({
+    // table_id: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const {} = e;
+    const { app_id, uid, table_id } = RunContext.context;
+
+    console.log('Get studio table info by table id:', table_id);
+    if (!table_id) throw new Error('got null in the table_id parameter');
+
+    try {
+      const project_db = await get_project_db(app_id);
+
+      let response = '';
+
+      try {
+        response = await project_db.get(table_id);
+      } catch (error) {
+        throw new Error(`table doc ${table_id} not found`);
+      }
+
+      if (_.isEmpty(response)) {
+        throw new Error(`table with table_id ${table_id} not found`);
+      }
+
+      return { tableFields: response.tableFields, tableIndexes: response.tableIndexes };
+    } catch (err) {
+      console.error('Get studio table info by table id:', table_id, err.message);
+      return err.message;
+    }
+  },
+});
+
+const get_database_doc_template_tool = tool({
+  name: 'Get Database Doc Template',
+  description: 'Get the table doc by table_id',
+  parameters: z.object({}),
+  async execute(e, RunContext) {
+    const {} = e;
+    const { app_id, uid, table_id } = RunContext.context;
+
+    console.log('Get Database Doc Template by table id:', table_id);
+    if (!table_id) throw new Error('got null in the table_id parameter');
+
+    try {
+      const project_db = await get_project_db(app_id);
+
+      let response = '';
+
+      try {
+        response = await project_db.get(table_id);
+      } catch (error) {
+        throw new Error(`table doc ${table_id} not found`);
+      }
+
+      if (_.isEmpty(response)) {
+        throw new Error(`table with table_id ${table_id} not found`);
+      }
+      const t = Date.now();
+
+      const doc = `
+
+                  {
+                    "_id": "dbs-${crypto.randomUUID()}", 
+                    "docType": "database", 
+                    "stat": 3, 
+                    "user":  "${uid}",
+                    "app_id":  "${app_id}",
+                    "udfData": {
+                      "udffileid": "${table_id}",
+                      "data": {
+                        "PG_Id": "1675955407146",
+                        "PG_BK_Id": "1629987722344",
+                        "PG_Page_Number": 5, 
+                        "PG_Chapter": "",
+                        "PG_Base_Url": "",
+                        "PG_PR_Id": 1675955409275,
+                        "PG_Chapter_Name": ""
+                      } 
+                    },
+                    "ts": ${t},
+                    "udfIndex": [
+                      {
+                        "fileId": "${table_id}",
+                        "indexId": "1629098020301",
+                        "keySegments": [ "PG_BK_Id","PG_Page_Number"],
+                        "keyValue": [
+                          "1629987722344",
+                          5
+                        ]
+                      },
+                      {
+                        "fileId": "${table_id}",
+                        "indexId": "1629968420532",
+                        "keySegments": ["PG_Id"],
+                        "keyValue": [
+                          "1675955407146"
+                        ]
+                      },
+                      {
+                        "fileId": "${table_id}",
+                        "indexId": "1629969152311",
+                        "keySegments": ["PG_BK_Id"],
+                        "keyValue": [
+                          "1629987722344"
+                        ]
+                      }
+                    ] 
+                  } 
+    `;
+
+      return doc;
+    } catch (err) {
+      console.error('Get studio table info by table id:', table_id, err.message);
+      return err.message;
+    }
+  },
+});
+
+// const add_data_to_table_tool = tool({
+//   name: 'Add data to table tool',
+//   description: 'Add data to a table by receiving a table_id and a data object containing key–value pairs representing the fields and their values.',
+//   parameters: z.object({
+//     table_id: z.string(),
+//   }),
+//   async execute(e, RunContext) {
+//     const { table_id } = e;
+//     const { app_id, uid } = RunContext.context;
+
+//     if (!table_id) throw new Error('got null in the table_id parameter');
+
+//     try {
+//       const project_db = await get_project_db(app_id);
+
+//       let response = '';
+
+//       try {
+//         response = await project_db.get(table_id);
+//       } catch (error) {
+//         throw new Error(`table doc ${table_id} not found`);
+//       }
+
+//       if (_.isEmpty(response)) {
+//         throw new Error(`table with table_id ${table_id} not found`);
+//       }
+
+//       return response;
+//     } catch (err) {
+//       return err.message;
+//     }
+//   },
+// });
+
+// let table_tools = {};
+// const build_studio_table_tools = async function (app_id) {
+//   try {
+//     if (!table_tools[app_id]) {
+//       table_tools[app_id] = {};
+//     }
+
+//     const project_db = await get_project_db(app_id);
+//     let tables = await project_db.view('xuda', 'studio_docs_by_type', { key: 'table' });
+
+//     for (const table_header_doc of tables.rows) {
+//       try {
+//         const doc = await project_db.get(table_header_doc.id);
+
+//         let data_parameters = {};
+
+//         for (const field of doc.tableFields || []) {
+//           const fieldId = field.data.field_id;
+//           const fieldType = field.props.fieldType;
+//           const mandatory = field.props.mandatory;
+//           const comment = field.props.fieldComment;
+
+//           let zodType;
+//           switch (fieldType) {
+//             case 'string':
+//               zodType = z.string();
+//               break;
+//             case 'number':
+//               zodType = z.number();
+//               break;
+//             case 'array':
+//               zodType = z.array(z.any());
+//               break;
+//             case 'object':
+//               zodType = z.object({});
+//               break;
+//             default:
+//               zodType = z.any();
+//           }
+
+//           // Add description if comment exists
+//           if (comment) {
+//             zodType = zodType.describe(comment);
+//           }
+
+//           // Make optional if not mandatory
+//           if (!mandatory) {
+//             zodType = zodType.optional();
+//           }
+
+//           data_parameters[fieldId] = zodType;
+//         }
+
+//         const _tool = {
+//           name: `add data to table tool`,
+//           description: `Add data to ${doc.properties.menuName} table by receiving key–value pairs representing the fields and their values.`,
+//           parameters: z.object(data_parameters),
+//           // parameters: z.object({ ...{ table_id: z.string() }, ...data_parameters }),
+//           // parameters: z.object({
+//           //   table_id: z.string(),
+//           //   data: z.object(data_parameters),
+//           // }),
+//           async execute(e, RunContext) {
+//             debugger;
+//             const {} = e;
+//             const { app_id, uid, table_id } = RunContext.context;
+//             let response = '';
+//             try {
+//               if (!table_id) throw new Error('got null in the table_id parameter');
+
+//               const FlexibleDatabaseSchema = z.object({
+//                 _id: z.string(),
+//                 _rev: z.string(),
+//                 docType: z.literal('database'),
+//                 stat: z.number(),
+//                 udfData: z.object({
+//                   udffileid: z.string(),
+//                   data: z.record(z.union([z.string(), z.number()])), // Any key-value pairs
+//                   error: z.object({}).optional(),
+//                 }),
+//                 ts: z.number(),
+//                 date: z.number(),
+//                 udfIndex: z.array(
+//                   z.object({
+//                     fileId: z.string(),
+//                     indexId: z.string(),
+//                     keySegments: z.array(z.any()),
+//                     keyValue: z.array(z.any()),
+//                   }),
+//                 ),
+//               });
+
+//               // for (const [key, val] of Object.entities(data || {})) {
+//               // }
+
+//               let udfIndex = [];
+
+//               for (const [key, val] of Object.entities(doc.tableIndexes || [])) {
+//                 let keyValue = [];
+//                 for (const key_val of val?.data?.keys || []) {
+//                   keyValue.push(data[key_val]);
+//                 }
+
+//                 udfIndex.push({
+//                   fileId: table_id,
+//                   indexId: val.id,
+//                   keySegments: val?.data?.keys || [],
+//                   keyValue,
+//                 });
+//               }
+//               const t = Date.now();
+//               let table_obj = {
+//                 _id: 'dbs-' + crypto.randomUUID(),
+
+//                 docType: 'database',
+//                 stat: 3,
+//                 udfData: {
+//                   udffileid: table_id,
+//                   data: e,
+//                   error: {},
+//                 },
+//                 ts: t,
+//                 date: t,
+//                 udfIndex,
+//               };
+
+//               return response;
+//             } catch (err) {
+//               return err.message;
+//             }
+//           },
+//         };
+
+//         // const jsonSchema = zodToJsonSchema(_tool.parameters, 'UserSchema');
+
+//         // console.log(JSON.stringify(jsonSchema, null, 2));
+
+//         table_tools[app_id][doc._id] = tool(_tool);
+//       } catch (error) {
+//         throw new Error(`table doc ${doc.id} not found`);
+//       }
+//     }
+//     // console.log(studio_units);
+//   } catch (err) {
+//     console.error(err);
+//   }
+
+//   return table_tools[app_id];
+// };
+
+const get_mock_data_generator_agent = function (app_id, table_id) {
+  return new Agent({
+    name: `Mock Data Generator Agent`,
+    instructions: `You are a Mock Data Generator Assistant for table id ${table_id}. Help the user populate data for table id ${table_id} with sample data. First, retrieve the table field definitions using get_studio_table_info_by_table_id_tool. Then generate five realistic mock data samples based on the table structure and insert each one individually using add data to table tool.`,
+    // instructions: `You are a Mock Data Generator Assistant.
+    // 1. First, get table info using the get_studio_table_info_by_table_id tool with table_id: ${table_id}
+    // 2. Analyze the table structure and field types
+    // 3. Generate 5 realistic mock data samples based on the fields
+    // 4. Return the generated data in a structured format`,
+    model,
+    tools: [get_studio_table_info_by_table_id_tool, table_tools[app_id][table_id]], //, table_tools[app_id][table_id]
+    // modelSettings: { toolChoice: 'required' },
+  });
+};
+
+// const get_add_data_to_table_agent = function (app_id, table_id) {
+//   return new Agent({
+//     name: `Add Data to Table Agent`,
+//     instructions: `You are an Add Data Assistant for table ID ${table_id}. Your job is to help the user provide valid data for this table. First, retrieve the table field definitions using get_studio_table_info_by_table_id_tool. Then prepare the data as key–value pairs (e.g., { first_name: "John", last_name: "Smith" }) and submit it using the add_data_to_table_tool. Generate UUID values for required unique fields when necessary. Ignore extra fields from the user prompt, and skip optional fields if not provided.`,
+//     model,
+//     tools: [get_studio_table_info_by_table_id_tool, table_tools[app_id][table_id]],
+//     modelSettings: { toolChoice: 'required' },
+//   });
+// };
+
+const validate_table_data_doc = tool({
+  name: 'Validate Table Data Doc',
+  description: 'Validate the table doc structure',
+  parameters: z.object({
+    doc: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const { doc } = e;
+    const { app_id, uid, table_id } = RunContext.context;
+
+    console.log('validate_table_data_doc', doc);
+    if (!table_id) throw new Error('got null in the table_id parameter');
+
+    try {
+      const project_db = await get_project_db(app_id);
+
+      let response = '';
+
+      try {
+        response = await project_db.get(table_id);
+      } catch (error) {
+        throw new Error(`table doc ${table_id} not found`);
+      }
+
+      const dataDocSchema = z.object({
+        _id: z.string(),
+        // _rev: z.string(),
+        docType: z.literal('database'),
+        stat: z.number(),
+        udfData: z.object({
+          udffileid: z.string(),
+          data: z.record(z.union([z.string(), z.number()])), // Any key-value pairs
+          error: z.object({}).optional(),
+        }),
+        ts: z.number(),
+        date: z.number(),
+        udfIndex: z.array(
+          z
+            .object({
+              fileId: z.string(),
+              indexId: z.string(),
+              keySegments: z.array(z.any()),
+              keyValue: z.array(z.any()),
+            })
+            .optional(),
+        ),
+      });
+      const doc_obj = JSON5.parse(doc);
+      try {
+        const data_doc = dataDocSchema.parse(doc_obj);
+      } catch (err) {
+        if (err instanceof z.ZodError) {
+          console.log('Validation failed:', err.errors);
+          // return { success: false, errors: err.errors };
+          throw new Error(err.errors);
+        }
+        throw new Error(err.message);
+      }
+
+      return 'table structure ok';
+    } catch (err) {
+      console.error('validate_table_data_doc', table_id, err.message);
+      return err.message;
+    }
+  },
+});
+
+const delete_table_doc = new Agent({
+  name: `Delete Table Doc`,
+  instructions: ` 
+      
+      You are an Delete Table Doc Assistant responsible for deleting doc in a table.
+      don't prompt for any questions,table is known with context, just do your job using tools.
+      When the user provides a prompt, follow this workflow:
+
+      1. Retrieve the table’s field definitions using the **Get Studio Table Info** tool.
+      2. Build a Mango query object using only fields that exist in the table schema (e.g., 'udfData.data.field_name'), and always include "docType": "database" (see **Query Example**) 
+      3. Submit the constructed query to the **Fetch Table Data** tool.
+      4. If query errors fix and re-submit the query to the **Fetch Table Data** tool.
+      5. If the query return 1 doc then continue otherwise show the user the results and ask to be more specific  
+      6. Send the _id to the **Delete Doc By _id** tool to complete the process
+      
+
+       ## Output Example:
+
+      #|Name    |Email       |Role
+      -+--------+------------+----------
+      1| John   |j@gmail.com | Manager
+
+      ## Query Example
+
+      {
+        "selector": {
+        "docType": "database", <--- must be in every query
+        "stat": 3,  <--- must be in every query
+        "udfData.data.UID": "12345", 
+        "limit": 25,
+        "skip": 0 
+      }
+
+      every table field must begin with prefix: udfData.data.
+
+      const query = {
+        selector: {
+          docType: "database",
+          stat: 3,
+          "$and": [
+            { "STU_Username": "Boaz Avrahami" }  // ← WRONG: no prefix
+          ]
+        },
+        fields: ["STU_Uuid", "STU_Username", ...],  // ← WRONG
+        limit: 25,
+        skip: 0
+};
+
+       
+`,
+  model,
+  tools: [get_studio_table_info_by_table_id_tool, fetch_data_tool, delete_doc_tool],
+  modelSettings: { toolChoice: 'required' },
+});
+
+const add_data_to_table_agent = new Agent({
+  name: `Add Data to Table Agent`,
+  instructions: ` 
+      
+      You are an Add Data Assistant responsible for creating new records in a table.
+      don't prompt for any questions,table is known with context, just do your job using tools.
+      When the user provides a prompt, follow this workflow:
+
+      1. Retrieve the table’s field and index definitions using the **Get Studio Table Info** tool.
+      2. Retrieve the base data template using the **Get Database Doc Template** tool.
+      3. Replace the template’s 'udfData.data' section with the values extracted from the prompt.
+        If some fields are not provided, insert them with empty values based on the table’s field definitions.
+      4. Replace the 'udfIndex' accordingly.
+      5. Validate the document against ##Validate Table Data Doc## tool
+      6. If validation return error then retry otherwise continue to step 7
+      7. Save the completed document using the **Save Doc** tool. 
+`,
+  model,
+  tools: [get_studio_table_info_by_table_id_tool, get_database_doc_template_tool, validate_table_data_doc, save_doc_tool],
+  modelSettings: { toolChoice: 'required' },
+});
+
+const fetch_table_data_agent = new Agent({
+  name: `Fetch Table Data Agent`,
+  instructions: ` 
+    
+      You are a Fetch Table Data Assistant responsible for retrieving records from a table, 
+      don't prompt for any questions, just fetch with defaults using tools.
+      When the user provides a prompt, follow this workflow:
+
+      1. Retrieve the table’s field definitions using the **Get Studio Table Info** tool.
+      2. Build a Mango query object using only fields that exist in the table schema (e.g., 'udfData.data.field_name'), and always include "docType": "database" (see **Query Example**).
+      3. Submit the constructed query to the **Fetch Table Data** tool.
+      4. If query errors fix and re-submit the query to the **Fetch Table Data** tool.
+      5. If a 'no_usable_index' error is returned, create the required index object (see **Index Example**) using the **Create Index** tool, wait 20 seconds, and then run the query again.
+      6. output with organized table grid style columns and rows ## Output Example:
+
+
+      ## Output Example:
+
+      #|Name    |Email       |Role
+      -+--------+------------+----------
+      1| John   |j@gmail.com | Manager
+
+      ## Query Example
+
+      {
+        "selector": {
+        "docType": "database", <--- must be in every query
+        "stat": 3,  <--- must be in every query
+          "$and": [
+            {
+              "udfData.data.type": "product",
+              "udfData.data.category": {"$in": ["electronics", "books"]},
+              "udfData.data.price": {
+                "$gte": 10,
+                "$lte": 1000
+              },
+              "udfData.data.stock": {"$gt": 0},
+              "udfData.data.tags": {"$all": ["featured", "new"]},
+              "udfData.data.rating": {"$exists": true}
+            }
+          ],
+          "$or": [
+            {"udfData.data.featured": true},
+            {"udfData.data.promotion": true}
+          ],
+          "$not": {
+            "udfData.data.status": "discontinued"
+          }
+        },
+        "fields": [
+          "udfData.data._id",
+          "udfData.data.name",
+          "udfData.data.price",
+          "udfData.data.category",
+          "udfData.data.rating",
+          "udfData.data.image"
+        ],
+        "sort": [
+          {"udfData.data.rating": "desc"},
+          {"udfData.data.price": "asc"},
+          {"udfData.data.name": "asc"}
+        ],
+        "limit": 25,
+        "skip": 0 
+      }
+
+
+      every table field must begin with prefix: udfData.data.
+
+      const query = {
+        selector: {
+          docType: "database",
+          stat: 3,
+          "$and": [
+            { "STU_Username": "Boaz Avrahami" }  // ← WRONG: no prefix
+          ]
+        },
+        fields: ["STU_Uuid", "STU_Username", ...],  // ← WRONG
+        limit: 25,
+        skip: 0
+};
+
+       ## Index Example
+
+       {
+        "index": {
+          "fields": ["udfData.data.docType", "udfData.data.stat", "udfData.data.type"]
+        },
+        "name": "basic_query_index",
+        "ddoc": "agent_indexes",
+      }
+
+`,
+  model,
+  tools: [get_studio_table_info_by_table_id_tool, fetch_data_tool, create_index_tool],
+  modelSettings: { toolChoice: 'required' },
+});
+
+// const add_data_to_table = tool({
+//   name: 'Create table agent',
+//   description: 'crete agent that handles table tools by providing table_id',
+//   parameters: z.object({
+//     table_id: z.string(),
+//   }),
+//   async execute(e, RunContext) {
+//     const { table_id } = e;
+//     const { app_id, uid } = RunContext.context;
+//     let response = '';
+//     try {
+//       if (!table_id) throw new Error('got null in the table_id parameter');
+//       let table_doc = {};
+//       const project_db = await get_project_db(app_id);
+//       try {
+//         table_doc = await project_db.get(table_id);
+//       } catch (error) {
+//         throw new Error(`table doc ${table_id} not found`);
+//       }
+
+//       const agent_name = `${table_doc.properties.menuName} table AI Agent`;
+
+//       try {
+//         const ai_agents_ret = await get_ai_agents({ uid });
+//         for (const doc of ai_agents_ret?.data?.docs || []) {
+//           if (doc.properties.menuName === table_doc.properties.menuName) {
+//             throw new Error(`ai agent for ${table_id} already exist with name ${agent_name}`);
+//           }
+//         }
+//       } catch (err) {
+//         debugger;
+//         console.error(err);
+//         // throw new Error(err.message);
+//       }
+
+//       const agentConfig = {
+//         agent_name,
+//         agent_tools: [
+//           {
+//             type: 'table',
+//             prog_id: table_id,
+//           },
+//         ],
+//         agent_instructions: 'You are a Table Data Assistant. Your role is to query, analyze, and modify data within tables as requested. You can retrieve specific information, perform calculations, filter or sort records, and apply updates or structural changes to the data when necessary.',
+//       };
+
+//       response = await create_ai_agent({
+//         uid,
+//         agentConfig,
+//       });
+
+//       return { response, agentConfig };
+//     } catch (err) {
+//       return err.message;
+//     }
+//   },
+// });
+
+const create_agent_for_table_assistant_tool = tool({
+  name: 'Create table agent',
+  description: 'crete agent that handles table tools by providing table_id',
+  parameters: z.object({
+    table_id: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const { table_id } = e;
+    const { app_id, uid } = RunContext.context;
+    let response = '';
+    try {
+      if (!table_id) throw new Error('got null in the table_id parameter');
+      let table_doc = {};
+      const project_db = await get_project_db(app_id);
+      try {
+        table_doc = await project_db.get(table_id);
+      } catch (error) {
+        throw new Error(`table doc ${table_id} not found`);
+      }
+
+      const agent_name = `${table_doc.properties.menuName} table AI Agent`;
+
+      const ai_agents_ret = await get_ai_agents({ uid });
+      for (const doc of ai_agents_ret?.data?.docs || []) {
+        if (doc.properties.menuName === agent_name) {
+          throw new Error(`ai agent for ${table_id} already exist with name ${agent_name}`);
+        }
+      }
+
+      const agentConfig = {
+        agent_name,
+        agent_tools: [
+          {
+            type: 'table',
+            prog_id: table_id,
+          },
+        ],
+        agent_instructions: 'You are a Table Data Assistant. Your role is to query, analyze, and modify data within tables as requested. You can retrieve specific information, perform calculations, filter or sort records, and apply updates or structural changes to the data when necessary.',
+      };
+
+      response = await create_ai_agent({
+        uid,
+        agentConfig,
+      });
+
+      return { response, agentConfig };
+    } catch (err) {
+      return err.message;
+    }
+  },
+});
+
+const create_agent_for_table_assistant = new Agent({
+  name: 'Create Agent for Table Assistant',
+  instructions:
+    'You are a Table Agent Creation Assistant. Your role is to dynamically create a table-specific agent when given a table ID or table name. If you receive a table name, use the get_studio_table_info_tool to obtain its table ID. Once the table ID is available, use the create_agent_for_table_assistant_tool to generate and configure the new table agent associated with that table.',
+  model,
+  tools: [get_studio_table_info_tool, create_agent_for_table_assistant_tool],
+  modelSettings: { toolChoice: 'required' },
+});
+
+// const get_studio_tables = tool({
+//   name: 'Get studio tables',
+//   description: 'fetch all studio tables',
+//   parameters: z.object({
+//     app_id: z.string(),
+//   }),
+//   async execute(e, RunContext) {
+//     const { app_id } = e;
+//     try {
+//       const project_db = await get_project_db(app_id);
+//       let tables = await project_db.view('xuda', 'studio_docs_by_type', { key: 'table', include_docs: true });
+
+//       return tables;
+//     } catch (err) {
+//       return 'unknown';
+//     }
+//   },
+// });
+
+const get_account_info = async function (uid) {
+  try {
+    const db = get_xuda_couch('xuda_accounts');
+    const doc = await db.get(uid);
+
+    return doc.account_info || {};
+  } catch (err) {
+    return err.message;
+  }
+};
+
+const get_user_name = async function (uid) {
+  try {
+    const account_info = await get_account_info(uid);
+    let username = 'unknown';
+    if (account_info) {
+      username = account_info.first_name + ' ' + account_info.last_name;
+
+      if (!username) {
+        username = +account_info.email;
+      }
+    }
+
+    return username;
+  } catch (err) {
+    return 'unknown';
+  }
+};
+
+const get_user_name_tool = tool({
+  name: 'get_user_name_tool',
+  description: 'Get the user name by uid',
+  parameters: z.object({
+    uid: z.string(),
+  }),
+  async execute(e, RunContext) {
+    const { uid } = e;
+
+    return await get_user_name(uid);
+    // try {
+    //   const db = get_xuda_couch('xuda_accounts');
+    //   const doc = await db.get(e.uid);
+    //   let username = 'unknown';
+    //   if (doc?.account_info) {
+    //     username = doc.account_info.first_name + ' ' + doc.account_info.last_name;
+
+    //     if (!username) {
+    //       username = +doc.account_info.email;
+    //     }
+    //   }
+
+    //   return username;
+    // } catch (err) {
+    //   return 'unknown';
+    // }
+  },
+});
+
+const create_initial_studio_doc_tool = tool({
+  name: 'Create initial studio doc tool',
+  description: 'I am responsible to create initial doc for the studio',
+  parameters: z.object({
+    uid: z.string().describe('the user id'),
+    app_id: z.string().describe('the app id'),
+    menuType: z.enum(valid_menuType).describe('the studio doc type'),
+    checkedInUserName: z.string().describe('the name of check-in user'),
+    parentId: z.string().describe('the doc id of the parent doc'),
+  }),
+  async execute(e, RunContext) {
+    // console.log('create_initial_studio_doc_tool >>>> ', e);
+    const { uid, menuType, checkedInUserName, app_id, parentId } = e;
+    try {
+      const doc = createDoc({ uid, properties: { menuType }, checkedInUserName, app_id, parentId });
+
+      return doc;
+    } catch (err) {
+      return 'unknown';
+    }
+  },
+});
+
+const check_studio_doc_tool = tool({
+  name: 'Check studio doc',
+  description: 'I am responsible to check and validate studio doc',
+  parameters: z.object({
+    app_id: z.string().describe('the app id'),
+    doc: z.string().describe('the studio doc to validate for table,globals,components and more'),
+  }),
+  async execute(e, RunContext) {
+    try {
+      const doc = JSON5.parse(e.doc);
+      let progs = {};
+
+      const app_obj = await get_app_obj(e.app_id);
+      const project_db = await get_project_db(e.app_id);
+      let studio_nodes = await project_db.view('xuda', 'studio_nodes', {});
+      for (const doc of studio_nodes.rows) {
+        progs[doc.value._id] = doc.value;
+      }
+
+      init(app_obj, progs, _, true, null, null, UglifyJS, JSON5, _conf, true, z);
+      let result = check(doc);
+      console.log('check_studio_doc_tool >>>> ', result.check_errors, e.doc);
+      delete result.doc;
+      return result;
+    } catch (err) {
+      console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const get_plugins = tool({
+  name: 'Get plugins',
+  description: 'I am responsible to return all available plugins',
+  parameters: z.object({}),
+  async execute(e, RunContext) {
+    try {
+      const db = get_xuda_couch('xuda_plugins');
+      const plugins_res = await db.view('xuda', 'all-active-plugins', {});
+      let data = [];
+      if (!_.isEmpty(plugins_res.rows)) {
+        for (val of plugins_res.rows) {
+          if (!['library', 'widget', 'ui'].includes(val.plugin_type)) continue;
+          var plugin = _.clone(val.value);
+          delete plugin.account_id;
+          delete plugin.manifest;
+          delete plugin.plugin_name;
+          delete plugin.setup;
+          delete plugin.stat;
+          delete plugin.updated_date;
+          plugin._id = plugin._id.replace('@xuda.io/', '');
+
+          data.push(plugin);
+        }
+      }
+
+      console.log('get_plugins >>>> ', data);
+      return data;
+    } catch (err) {
+      console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const update_app_doc_tool = tool({
+  name: 'update app doc tool',
+  description: 'update any app doc query by _id and _rev and save to the app db',
+  parameters: z.object({
+    app_id: z.string(),
+    doc: z.object({ _id: z.string(), _rev: z.string() }),
+  }),
+  async execute(e, RunContext) {
+    console.log(`SAVED ${e.app_id}`);
+    return `OK`;
+  },
+});
+
+const get_app_doc_tool = tool({
+  name: 'get app doc tool',
+  description: 'get any doc by id from the app db',
+  parameters: z.object({
+    app_id: z.string(),
+    _id: z.string(),
+  }),
+  async execute(e, RunContext) {
+    try {
+      const project_db = await get_project_db(e.app_id);
+
+      const result = await project_db.get(_id);
+      console.log('get_app_doc_tool >>>> ', result);
+      return result;
+    } catch (err) {
+      console.error(err);
+      return err.message;
+    }
+  },
+});
+
+const get_additional_information_tool = tool({
+  name: 'get additional information tool',
+  description: 'get additional information for object unit tool',
+  parameters: z.object({
+    object_unit: z.enum(['table']),
+  }),
+  async execute(e, RunContext) {
+    let obj = { table: ['studio_table'] };
+    const db = get_xuda_couch('xuda_website');
+    try {
+      if (!obj[e.object_unit]) throw new Error(`${e.object_unit} not found`);
+      const doc = await db.get(obj[e.object_unit]);
+      // console.log(`INFO ${doc}`);
+      return doc.md || doc;
+    } catch (err) {
+      console.error(err);
+      return err.message;
+    }
+  },
+});
+
+export const submit_agentic_studio_chat_gpt_prompt = async function (req) {
+  try {
+    const { user_prompt, object_unit = 'app', uid, app_id } = req;
+    // const model = 'ft:gpt-4o-2024-08-06:xuda-io:vps-hosting-plans:CDaxQiXo'; // 'gpt-4o'; //'gpt-4.1'; //
+
+    const app_obj = await get_app_obj(app_id);
+
+    // let check_results = {};
+    const auth = async function () {
+      if (app_obj.app_uId !== uid) {
+        const db_team = get_xuda_couch('xuda_team');
+        let master_auth_users = await db_team.view('xuda', 'user_active_shares', {
+          key: [uid, app_id],
+        });
+        if (!master_auth_users.rows.includes(uid)) {
+          throw new Error('user unauthorized');
+        }
+      }
+    };
+
+    await auth();
+
+    const userName = await get_user_name(uid);
+
+    const get_zod_unit_schema = function (type) {
+      init(app_obj, {}, _, true, null, null, UglifyJS, JSON5, _conf, false, z);
+      const schema = get_zod_schema(type);
+      const jsonSchema = zodToJsonSchema(schema);
+      return JSON.stringify(jsonSchema, null, 2);
+    };
+
+    const get_app_instructions = function (object_unit) {
+      return ` 
+            ### context ###
+            uid=${uid}
+            app_id=${app_id}
+  
+            ### Persona & Role ###
+            - You are a helpful and professional technical assistant named ${object_unit} builder.  
+
+            ### Tasks ### 
+ 
+            Your job is to assist the user with creating a ${user_prompt} that includes all tasks needed.
+
+
+             ### workflow ### 
+ 
+            Steps:
+            1. list all the tables needed for the task.
+            2. prefix each table with the subject of the ${user_prompt} (e.g: CRM - Tasks).
+            3. iterate the table list and build tables array using the Table builder tool, add the Table builder tool results and the table name in array RESULTS_ARR.
+ 
+           
+            ### Additional information ###
+            
+            
+
+            ### Output ###
+           return  the RESULTS_ARR Array.
+
+            ### Examples ###
+ 
+`;
+    };
+
+    const get_table_instructions = function (object_unit) {
+      return `
+            ### context ###
+            uid=${uid}
+            app_id=${app_id}
+  
+            ### Persona & Role ###
+            - You are a helpful and professional technical assistant named ${object_unit} builder.   
+
+            ### Tasks ### 
+ 
+            Your job is to assist the user with creating a ${user_prompt} that includes a full set of fields according to the provided ${object_unit} structure.
+
+              - You must include all relevant fields a typical ${user_prompt} would require 
+              - Add **multiple entries** in the "tableFields" array as needed to fully represent the structure.
+              - Follow the format and conventions shown in the ${object_unit} structure example.
+              - use uid for  "createdByUid" and "checkedInUserId"  
+            
+            ### workflow ### 
+ 
+            Steps:
+            1. Use create_initial_studio_doc_tool to create the initial doc assign the return result in "doc" variable.
+            
+            3. Use check_studio_doc_tool to check the ${object_unit} send the ${object_unit} as the doc, fix the issues if needed. if the check fail for 3 times the throw error, skip **Save Doc** tool  if errors exist
+            4. Use **Save Doc** tool  to save the ${object_unit} doc and update the result in save_result variable,NEVER save if errors exist after check_studio_doc_tool
+
+  
+            ### Output ###
+            if success: {code:1,data:save_result}
+            if fail: {code:-1,data:error} 
+
+            ### EXAMPLE
+
+              {
+                "_id": "5b1_tbl_47f0ac6059ca", 
+                "app_id": "prj3937cb6f9a31c8c7dea25055bba845b1",
+                "stat": 3,
+                "docType": "studio",
+                "docDate": 1714916369797,
+                "ts": 1762953659001,
+                "order_ts": 1714916369797,
+                "studio_meta": {
+                  "created": 1714916369797,
+                  "createdByUid": "341cf2d32991a68e4d8aaba6c16e15cc",
+                  "checkedInUserId": "341cf2d32991a68e4d8aaba6c16e15cc",
+                  "checkedInUserName": "Ioshka Media",
+                  "parentId": "database",
+                  "savedByUid": "341cf2d32991a68e4d8aaba6c16e15cc"
+                },
+                "properties": {
+                  "menuType": "table",
+                  "menuName": "PT - Practice Table",
+                  "databaseSocket": "@xuda.io/xuda-dbs-plugin-xuda", 
+                  "menuTitle": "PT - Practice Table"
+                },
+                "tableIndexes": [
+                  {
+                    "id": "76bbf201-997e-402c-b435-0649cc25d117",
+                    "data": {
+                      "name": "Primary_Index",
+                      "unique": true,
+                      "keys": [
+                        "PT_Id"
+                      ]
+                    },
+                    "props": {} <-- must appear even if empty
+                  },
+                  {
+                    "id": "89f1609d-de4e-4b61-9357-284b1261314c",
+                    "data": {
+                      "name": "Index_2",
+                      "unique": false,
+                      "keys": [
+                        "PT_Stat",
+                        "PT_Group_Id"
+                      ]
+                    },
+                    "props": {} <-- must appear even if empty
+                  }
+                ],
+                "tableFields": [
+                  {
+                    "id": "b41aa880-56ec-4029-a21b-60c89a52b62e",
+                    "data": {
+                      "field_id": "PT_Id"
+                    },
+                    "props": {
+                      "label":"Practice Id", 
+                      "fieldType": "string",
+                      "mandatory": true
+                    }
+                    
+                  },
+                  {
+                    "id": "8aec82db-35d9-4828-9fc7-49373c531cc3",
+                    "data": {
+                      "field_id": "PT_Type"
+                    },
+                    "props": {
+                      "label":"Practice Type", 
+                      "fieldType": "string",
+                      "mandatory": true
+                    }
+                    
+                  },
+                  {
+                    "id": "d27c56e5-faec-4a0a-ad42-7bf55f8c67b3",
+                    "data": {
+                      "field_id": "PT_Stat"
+                    },
+                    "props": {
+                       "label":"Practice Status", 
+                      "fieldType": "number",
+                      "fieldComment": "1 = Draft\n2 = Private\n3 = Public\n4 = Deleted",
+                      "mandatory": true
+                    }
+                    
+                  },
+                  {
+                    "id": "659fbfb3-7dcc-4ea0-b1e9-5dd9553a99fc",
+                    "data": {
+                      "field_id": "PT_Question"
+                    },
+                    "props": {
+                      "label":"Practice Question", 
+                      "fieldType": "string"
+                    }
+                    
+                  },
+                  {
+                    "id": "080c8ceb-5a51-437b-8ad1-9fc005c79011",
+                    "data": {
+                      "field_id": "PT_Options"
+                    },
+                    "props": {
+                      "label":"Practice Options", 
+                      "fieldType": "array"
+                    }
+                    
+                  },
+                  {
+                    "id": "72c04aac-b3e7-4e7a-8a74-31075de3dbec",
+                    "data": {
+                      "field_id": "PT_Answer"
+                    },
+                    "props": {
+                      "label":"Practice Answer", 
+                      "fieldType": "string"
+                    }
+                    
+                  },
+                  {
+                    "id": "e37b08c6-f340-425a-bf01-809b28a486d3",
+                    "data": {
+                      "field_id": "PT_Matching_Answer"
+                    },
+                    "props": {
+                      "label":"Practice Matching Answer", 
+                      "fieldType": "object"
+                    },
+                    
+                  },
+                  {
+                    "id": "8ca4ace1-2010-45be-b7aa-2672ce0e6fea",
+                    "data": {
+                      "field_id": "PT_Group_Id"
+                    },
+                    "props": {
+                      "label":"Practice Group Id", 
+                      "fieldType": "string"
+                    }
+                    
+                  },
+                  {
+                    "id": "ae749c6d-1f39-4750-b79e-f016d50b8a11",
+                    "data": {
+                      "field_id": "PT_Difficulty"
+                    },
+                    "props": {
+                      "label":"Practice Difficulty", 
+                      "fieldType": "number"
+                    },
+                    
+                  },
+                  {
+                    "id": "5c5e7cb5-feee-4bc7-9d94-0ccd04a5eb06",
+                    "data": {
+                      "field_id": "PT_Uid"
+                    },
+                    "props": {
+                      "label":"Practice User Id", 
+                      "fieldType": "string"
+                    }
+                    
+                  }
+                ]
+              }
+`;
+    };
+
+    const get_folder_instructions = function (object_unit) {
+      return `
+            ### context ###
+            uid=${uid}
+            app_id=${app_id}
+  
+            ### Persona & Role ###
+            - You are a helpful and professional technical assistant named ${object_unit} builder.   
+
+            ### Tasks ### 
+ 
+            Your job is to assist the user with creating a ${user_prompt}. 
+              
+              - Follow the format and conventions shown in the ${object_unit} structure example.
+              - use uid for  "createdByUid" and "checkedInUserId"  
+            
+            ### workflow ### 
+ 
+            Steps:
+            1. Use create_initial_studio_doc_tool to create the initial doc assign the return result in "doc" variable.
+            2. Get the ${object_unit} structure example from ### Structure and Examples ### section.
+            3. Build the ${object_unit} and validate against vs_68af4c84631c81919709268c2d0f1687
+            4. Use check_studio_doc_tool to check the ${object_unit} send the ${object_unit} as the doc, fix the issues if needed. if the check fail for 3 times the throw error, skip **Save Doc** tool  if errors exist
+            5. Use **Save Doc** tool  to save the ${object_unit} doc and update the result in save_result variable,NEVER save if errors exist after check_studio_doc_tool
+
+
+            ### Additional information ###
+            ${studio_units[object_unit].short}
+
+
+            ### Output ###
+            if success: {code:1,data:save_result}
+            if fail: {code:-1,data:error} 
+`;
+    };
+
+    const get_component_instructions = function (object_unit) {
+      return `
+            ### context ###
+            uid=${uid}
+            app_id=${app_id}
+  
+            ### Persona & Role ###
+            - You are a helpful and professional technical assistant named ${object_unit} builder.   
+
+            ### Tasks ### 
+ 
+            Your job is to assist the user with creating a ${user_prompt} that includes modern ui using Tailwind
+
+              - You must include all relevant fields a typical ${user_prompt} would require 
+               
+              - Follow the format and conventions shown in the ${object_unit} structure example.
+              - use uid for  "createdByUid" and "checkedInUserId"  
+            
+            ### workflow ### 
+ 
+            Steps:
+            1. Use create_initial_studio_doc_tool to create the initial doc assign the return result in "doc" variable.
+            
+            2. use ### Structure and Examples ### section to build the object
+            3. Use check_studio_doc_tool to check the ${object_unit} send the ${object_unit} as the doc, fix the issues if needed. if the check fail for 10 times the throw error, skip **Save Doc** tool  if errors exist
+            4. Use **Save Doc** tool  to save the ${object_unit} doc and update the result in save_result variable,NEVER save if errors exist after check_studio_doc_tool
+
+
+            ### Additional information ###
+            ${studio_units[object_unit].short} 
+
+            ### Structure and Examples ###
+
+            ${get_zod_unit_schema('component')}
+            
+           
+
+
+            ### Output ###
+            if success: {code:1,data:save_result}
+            if fail: {code:-1,data:error} 
+`;
+    };
+    const get_get_data_instructions = function (object_unit) {
+      return `
+            ### context ###
+            uid=${uid}
+            app_id=${app_id}
+  
+            ### Persona & Role ###
+            - You are a helpful and professional technical assistant named ${object_unit} builder.   
+
+            ### Tasks ### 
+ 
+            Your job is to assist the user with creating a ${user_prompt}.
+
+              - You must include all relevant fields a typical ${user_prompt} would require 
+               
+              - Follow the format and conventions shown in the ${object_unit} structure example.
+              - use uid for  "createdByUid" and "checkedInUserId"  
+            
+            ### workflow ### 
+ 
+            Steps:
+            1. Use create_initial_studio_doc_tool to create the initial doc assign the return result in "doc" variable.
+            2. Get the ${object_unit} structure example from ### Structure and Examples ### section.
+            3. Build the ${object_unit} and validate against vs_68af4c84631c81919709268c2d0f1687 
+            4. Use check_studio_doc_tool to check the ${object_unit} send the ${object_unit} as the doc, fix the issues if needed. if the check fail for 10 times the throw error, skip **Save Doc** tool  if errors exist
+            5. Use **Save Doc** tool  to save the ${object_unit} doc and update the result in save_result variable,NEVER save if errors exist after check_studio_doc_tool
+
+
+            ### Additional information ###
+            ${studio_units[object_unit].short} 
+
+            ### Output ###
+            if success: {code:1,data:save_result}
+            if fail: {code:-1,data:error} 
+`;
+    };
+
+    const get_agents_as_a_tool = function (agent_list = []) {
+      let _tools = [];
+      for (const agent of agent_list) {
+        const _agent = new Agent(studio_agents_obj[agent]);
+        const tool = _agent.asTool({
+          toolName: studio_agents_obj[agent].name,
+          toolDescription: `Generate a ${agent} of the supplied text.`,
+        });
+
+        _tools.push(tool);
+      }
+
+      return _tools;
+    };
+
+    let studio_agents_obj = {
+      app: {
+        name: 'App builder',
+        instructions: get_app_instructions(),
+        tools: [get_user_name_tool],
+        model,
+        modelSettings: {
+          toolChoice: 'required', // ← this enables tool use
+          responseFormat: {
+            text: {
+              format: {
+                type: 'array', // or "markdown" if needed
+              },
+            },
+          },
+          outputType: z.array(z.object()),
+        },
+      },
+      table: {
+        name: 'Table builder',
+        instructions: get_table_instructions('table'),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, save_doc_tool], //fileSearchTool('vs_68af4c84631c81919709268c2d0f1687'), fileSearchTool('vs_68af473196a88191afc6610fddfe4a62')
+        model,
+        modelSettings: {
+          toolChoice: 'required', // ← this enables tool use
+          responseFormat: {
+            text: {
+              format: {
+                type: 'array', // or "markdown" if needed
+              },
+            },
+          },
+          outputType: z.array(
+            z.object({
+              _id: z.string(),
+              stat: z.number(),
+              docType: z.string(),
+              docDate: z.number(),
+              ts: z.number(),
+              order_ts: z.number(),
+              studio_meta: z.object({
+                created: z.number(),
+                createdByUid: z.string(),
+                checkedInUserId: z.string(),
+                savedByUid: z.string(),
+                checkedInUserName: z.string(),
+                parentId: z.string(),
+                source: z.string(),
+              }),
+              properties: z.object({
+                menuName: z.string(),
+                menuType: z.string(),
+                databaseSocket: z.string(),
+              }),
+              tableIndexes: z.array(
+                z.object({
+                  id: z.string(),
+                  data: z.object({
+                    name: z.string(),
+                    unique: z.boolean(),
+                    keys: z.array(z.string()),
+                  }),
+                  props: z.object({}),
+                }),
+              ),
+              tableFields: z.array(
+                z.object({
+                  id: z.string(),
+                  data: z.object({
+                    field_id: z.string(),
+                  }),
+                  props: z.object({
+                    label: z.string(),
+                    fieldType: z.string(),
+                  }),
+                }),
+              ),
+            }),
+          ),
+        },
+      },
+      folder: {
+        name: 'Folder builder',
+        instructions: get_folder_instructions('folder'),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, save_doc_tool], //fileSearchTool('vs_68af4c84631c81919709268c2d0f1687'), fileSearchTool('vs_68af44989e4881918fc8bf8e84c6ce03')
+        model, //: 'gpt-4o'
+        modelSettings: {
+          toolChoice: 'required', // ← this enables tool use
+          responseFormat: {
+            text: {
+              format: {
+                type: 'array', // or "markdown" if needed
+              },
+            },
+          },
+          outputType: z.array(
+            z.object({
+              _id: z.string(),
+              stat: z.number(),
+              docType: z.string(),
+              docDate: z.number(),
+              ts: z.number(),
+              order_ts: z.number(),
+              studio_meta: z.object({
+                created: z.number(),
+                createdByUid: z.string(),
+                checkedInUserId: z.string(),
+                savedByUid: z.string(),
+                checkedInUserName: z.string(),
+                parentId: z.string(),
+                source: z.string(),
+              }),
+              properties: z.object({
+                menuName: z.string(),
+                menuType: z.string(),
+                databaseSocket: z.string(),
+              }),
+            }),
+          ),
+        },
+      },
+      component: {
+        name: 'Component builder',
+        instructions: get_component_instructions('component'),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, save_doc_tool], //, fileSearchTool('vs_68af48a65cf88191a48a0f530d7e3919')
+        model,
+        modelSettings: {
+          toolChoice: 'required', // ← this enables tool use
+          responseFormat: {
+            text: {
+              format: {
+                type: 'array', // or "markdown" if needed
+              },
+            },
+          },
+          outputType: z.array(
+            z.object({
+              _id: z.string(),
+              stat: z.number(),
+              docType: z.string(),
+              docDate: z.number(),
+              ts: z.number(),
+              order_ts: z.number(),
+              studio_meta: z.object({
+                created: z.number(),
+                createdByUid: z.string(),
+                checkedInUserId: z.string(),
+                savedByUid: z.string(),
+                checkedInUserName: z.string(),
+                parentId: z.string(),
+                source: z.string(),
+              }),
+              properties: z.object({
+                menuName: z.string(),
+                menuType: z.string(),
+                databaseSocket: z.string(),
+              }),
+              progDataSource: z.object({}),
+              progFields: z.array(z.object({})),
+              progEvents: z.array(z.object({})),
+              progUi: z.array(z.object({})),
+            }),
+          ),
+        },
+      },
+      get_data: {
+        name: 'Get data builder',
+        instructions: get_get_data_instructions('get_data'),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, save_doc_tool], //fileSearchTool('vs_68af4c84631c81919709268c2d0f1687'), fileSearchTool('vs_68af530d4ba081919ca57eabb5ae117a')
+        model,
+        modelSettings: {
+          toolChoice: 'required', // ← this enables tool use
+          responseFormat: {
+            text: {
+              format: {
+                type: 'array', // or "markdown" if needed
+              },
+            },
+          },
+          outputType: z.array(
+            z.object({
+              _id: z.string(),
+              stat: z.number(),
+              docType: z.string(),
+              docDate: z.number(),
+              ts: z.number(),
+              order_ts: z.number(),
+              studio_meta: z.object({
+                created: z.number(),
+                createdByUid: z.string(),
+                checkedInUserId: z.string(),
+                savedByUid: z.string(),
+                checkedInUserName: z.string(),
+                parentId: z.string(),
+                source: z.string(),
+              }),
+              properties: z.object({
+                menuName: z.string(),
+                menuType: z.string(),
+                databaseSocket: z.string(),
+              }),
+              progDataSource: z.object({}),
+              progFields: z.array(z.object({})),
+              progEvents: z.array(z.object({})),
+            }),
+          ),
+        },
+      },
+    };
+
+    if (object_unit === 'app') {
+      const agents_as_a_tool_arr = get_agents_as_a_tool(['table', 'folder', 'component', 'get_data']);
+      studio_agents_obj.app.tools = [...studio_agents_obj.app.tools, ...agents_as_a_tool_arr];
+    }
+
+    const run = async function (user_prompt, object_unit) {
+      const _agent = new Agent(studio_agents_obj[object_unit]);
+      const runner = new Runner();
+
+      const result = await runner.run(_agent, user_prompt, {
+        context: { uid, app_id, userName },
+      });
+
+      return result;
+    };
+
+    const result = await run(user_prompt, object_unit);
+
+    return { code: 100, data: result.finalOutput };
+  } catch (err) {
+    debugger;
+    console.error('>>>>> AI:', err);
+    console.error('Cause:', err?.cause?.message);
+    return { code: -100, data: err.message };
+  }
+};
+
+export const get_chat_conversation = async function (req) {
+  let { conversation_id, order = 'asc', limit, after, _id, uid } = req;
+
+  if (_id) return await get_ai_doc({ uid, _id });
+
+  try {
+    const project_db = await get_account_project_db(uid);
+    const conversation_doc = await project_db.get(conversation_id);
+    let conversation = await client.conversations.items.list(conversation_id, { limit, order, after });
+
+    return { code: 15, data: { conversation, ...conversation_doc } };
+  } catch (err) {
+    return { code: -15, data: err.message };
+  }
+};
+
+export const get_ai_chats = async function (req) {
+  let { uid, reference_id, _id } = req;
+
+  const project_db = await get_account_project_db(uid);
+  try {
+    if (_id) return await get_ai_doc({ _id, uid });
+
+    // let opt = { selector: { docType: 'chat_conversation', uid, stat: 3 } };
+    // if (reference_id) {
+    //   opt.selector.reference_id = reference_id;
+    // }
+    // const data = await project_db.find(opt);
+
+    const ai_chats = await project_db.view('xuda', 'ai_chat_list', {
+      key: reference_id || '',
+    });
+
+    return { code: 2, data: { docs: ai_chats.rows.map((row) => row.value) } };
+  } catch (err) {
+    return { code: -2, data: err.message };
+  }
+};
+
+export const delete_ai_chat = async function (req) {
+  let { conversation_id, uid } = req;
+
+  const project_db = await get_account_project_db(uid);
+  try {
+    let conversation_doc = await project_db.get(conversation_id);
+    conversation_doc.stat = 4;
+    conversation_doc.ts = Date.now();
+    const data = await project_db.insert(conversation_doc);
+
+    client.conversations.delete(conversation_id);
+
+    return { code: 3, data };
+  } catch (err) {
+    return { code: -3, data: err.message };
+  }
+
+  // const db = get_xuda_couch('xuda_contacts');
+  // try {
+  //   let conversation_doc = await db.get(conversation_id);
+  //   conversation_doc.stat = 4;
+  //   conversation_doc.ts = Date.now();
+  //   const data = await db.insert(conversation_doc);
+
+  //   return { code: 1, data };
+  // } catch (err) {
+  //   return { code: -1, data: err.message };
+  // }
+};
+
+export const submit_chat_conversation = async function (req) {
+  const { uid, gtp_token /* agent_mode not used here */ } = req;
+  let { prompt, conversation_id, reference_type, reference_id } = req;
+
+  const project_db = await get_account_project_db(uid);
+
+  const app_id = await get_account_project_id(uid);
+  const app_obj = await get_app_obj(app_id);
+  const userName = await get_user_name(uid);
+  const account_info = await get_account_info(uid);
+  let context = { app_id, uid, userName, account_info, app_obj };
+
+  let conversation_doc = {
+    docType: 'chat_conversation',
+    title: prompt.substr(0, 40),
+    date_created_ts: Date.now(),
+    ts: Date.now(),
+    stat: 3,
+    uid,
+    messages: [],
+    reference_type,
+    reference_id,
+  };
+
+  // 1. Ensure we have a conversation doc in Couch
+  let conversation_exist;
+  try {
+    if (!conversation_id) throw new Error('no id');
+    conversation_doc = await project_db.get(conversation_id);
+    reference_type = conversation_doc.reference_type;
+    reference_id = conversation_doc.reference_id;
+    conversation_exist = true;
+  } catch (err) {
+    // new conversation
+    const conversation_obj = await client.conversations.create();
+    conversation_id = conversation_obj.id;
+    conversation_doc.conversation_obj = conversation_obj;
+    conversation_doc._id = conversation_id;
+  }
+
+  const get_agents = async function () {
+    const list = [];
+
+    let ai_agents_ret = {};
+    let modelSettings = {};
+
+    if (reference_type === 'ai_agents') {
+      modelSettings = { toolChoice: 'auto' };
+      ai_agents_ret = { code: 1, data: { docs: [{ id: reference_id }] } };
+    } else {
+      ai_agents_ret = await get_ai_agents({ uid });
+    }
+
+    for (const doc of ai_agents_ret.data.docs) {
+      let ai_agent_doc;
+      try {
+        ai_agent_doc = await project_db.get(doc.id);
+      } catch (error) {
+        continue;
+      }
+
+      // const ai_agent_ret = await get_ai_doc({ _id: doc.id, uid });
+      let tools = [];
+      let tool_resources = {};
+      // if (ai_agent_ret.code < 0) continue;
+      // const ai_agent_doc = ai_agent_ret.data;
+      for (const [key, val] of Object.entries(ai_agent_doc?.agentConfig?.agent_tools || [])) {
+        const { name, description } = val;
+        switch (val.type) {
+          case 'web_search': {
+            //hosted_web_search
+            tools.push(webSearchTool());
+            break;
+          }
+
+          case 'mcp': {
+            tools.push(
+              hostedMcpTool({
+                serverLabel: 'mcp_' + (val?.name?.replaceAll(' ', '_') || key), //ai_agent_doc.properties.menuName,
+                serverUrl: val.url,
+                headers: {
+                  Authorization: `Bearer ${val.authentication_key || gtp_token}`,
+                  'X-gtp-token': 'true',
+                  'Content-Type': 'application/json',
+                },
+                require_approval: 'never',
+              }),
+            );
+            break;
+          }
+
+          case 'cpi': {
+            try {
+              debugger;
+              const api_allow_methods = Object.keys(_conf.cpi_methods);
+              for (const method_name of api_allow_methods || []) {
+                const method_prop = _conf.cpi_methods[method_name];
+
+                if (!method_prop) continue;
+                if (method_prop.private) continue;
+                if (!method_prop.description) continue;
+
+                let inputSchema = {};
+
+                const get_z_item = function (key, val) {
+                  let prop = {};
+                  if (val.type === 'object' && val.items) {
+                    for (const [item_key, item_val] of Object.entries(val.items.properties)) {
+                      prop[item_key] = get_z_item(item_key, item_val);
+                      if (!val?.items?.required?.includes(item_key)) {
+                        prop[item_key] = prop[item_key].optional();
+                      }
+                    }
+                  }
+
+                  if (val.type === 'array') {
+                    prop = get_z_item('', val.items);
+                  }
+
+                  let _z = z[val.type](prop);
+
+                  if (!val.mandatory) {
+                    _z = _z.optional();
+                  }
+
+                  if (val.enum) {
+                    _z = z.enum(val.enum);
+                  }
+
+                  let valid_values = '';
+                  if (val.options) {
+                    valid_values = val.options.join(', ');
+                  }
+                  if (val.description) {
+                    const desc = val.name || key.replace(/_/g, ' ').replace(/\b(\w)/g, (_, char) => char.toUpperCase());
+                    _z = _z.describe((desc ? desc + ' - ' : '') + val.description + (valid_values ? ' Valid values: ' + valid_values : ''));
+                  }
+
+                  return _z;
+                };
+
+                if (method_prop.fields) {
+                  for (const [key, val] of Object.entries(method_prop.fields)) {
+                    inputSchema[key] = get_z_item(key, val);
+                  }
+                }
+
+                tools.push(
+                  tool({
+                    name: method_name.replace(/_/g, ' ').replace(/\b(\w)/g, (_, char) => char.toUpperCase()),
+                    description: method_prop.description,
+                    parameters: z.object(inputSchema),
+                    async execute(e, RunContext) {
+                      const params = e;
+                      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, ...{ gtp_token } }),
+                        });
+                        const ret = await response.json();
+                        return {
+                          content: [{ type: 'text', text: JSON.stringify(ret || '', null, 2) }],
+                        };
+                      } catch (err) {
+                        return 'unknown';
+                      }
+                    },
+                  }),
+                );
+              }
+            } catch (error) {
+              debugger;
+            }
+            break;
+          }
+
+          // case 'web_search': {
+          //   tools.push(
+          //     tool({
+          //       name: name || val.type,
+          //       description: description || val.type,
+          //       parameters: z.object({
+          //         query: z.string().describe('The search query text.'),
+          //         numResults: z.number().int().describe('Number of top search results to return.').default(3),
+          //       }),
+          //       async execute(e, RunContext) {
+          //         const { query, numResults } = e;
+          //         try {
+          //           const searchUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_redirect=1`;
+          //           const response = await fetch(searchUrl);
+          //           const data = await response.json();
+
+          //           // Simplify results
+          //           const results = (data.RelatedTopics || []).slice(0, numResults).map((item) => ({
+          //             title: item.Text,
+          //             url: item.FirstURL,
+          //           }));
+
+          //           return JSON.stringify(results, null, 2);
+          //         } catch (err) {
+          //           return 'unknown';
+          //         }
+          //       },
+          //     }),
+          //   );
+          //   break;
+          // }
+
+          case 'image_generate': {
+            tools.push(
+              tool({
+                name,
+                description,
+                parameters: z.object({
+                  prompt: z.string().describe('The prompt for the image.'),
+                  numGenerations: z.number().int().describe('Number generations to image create.').default(3),
+                }),
+                async execute(e, RunContext) {
+                  const { prompt, numGenerations = val?.image_generations } = e;
+                  try {
+                    const base64 = await create_image(prompt, undefined, undefined, numGenerations);
+                    // console.log(base64);
+
+                    return `<img src="data:image/jpg;base64,${base64}">`;
+                  } catch (err) {
+                    return 'unknown';
+                  }
+                },
+              }),
+            );
+            break;
+          }
+
+          case 'app_builder': {
+            tools.push(
+              tool({
+                name,
+                description,
+                parameters: z.object({
+                  prompt: z.string().describe('The prompt for the app builder.'),
+                }),
+                async execute(e, RunContext) {
+                  const { prompt } = e;
+                  try {
+                    const app_id = await get_account_project_id(uid);
+                    submit_agentic_studio_chat_gpt_prompt({ uid, app_id, user_prompt: prompt });
+                    return;
+                  } catch (err) {
+                    return 'unknown';
+                  }
+                },
+              }),
+            );
+            tools.push(get_studio_table_info_tool);
+
+            tools.push(
+              create_agent_for_table_assistant.asTool({
+                toolName: 'Create Agent for Table Assistant',
+                toolDescription: `Generate table ai agent from the supplied text.`,
+              }),
+            );
+
+            break;
+          }
+
+          case 'table': {
+            const table_id = val.prog_id;
+            // prompt += ` for table_id: ${table_id}`;
+            context.table_id = table_id;
+            tools.push(get_studio_table_info_by_table_id_tool);
+            //======== mock data ==========
+            // const mock_data_generator_agent = get_mock_data_generator_agent(app_id, table_id);
+            // tools.push(
+            //   mock_data_generator_agent.asTool({
+            //     toolName: 'Mock Data Generator',
+            //     toolDescription: `generate Mock Data to a table`,
+            //   }),
+            // );
+            // tools.push(get_studio_table_info_by_table_id_tool);
+
+            //======== add data ==========
+            tools.push(
+              add_data_to_table_agent.asTool({
+                toolName: 'add data to table',
+                toolDescription: `add data to table`,
+              }),
+            );
+
+            //======== fetch data ==========
+            tools.push(
+              fetch_table_data_agent.asTool({
+                toolName: 'Fetch Table Data Agent',
+                toolDescription: `fetch data from a table`,
+              }),
+            );
+
+            //======== delete data ==========
+            tools.push(
+              delete_table_doc.asTool({
+                toolName: 'Delete Table Doc',
+                toolDescription: `The tool delete document from the database, need to ask for table`,
+              }),
+            );
+
+            tools.push(create_table_management_tool);
+
+            tools.push(create_landing_page_tool);
+
+            // const add_data_to_table_agent = get_add_data_to_table_agent(app_id, table_id);
+            // tools.push(
+            //   add_data_to_table_agent.asTool({
+            //     toolName: 'add data to table',
+            //     toolDescription: `add data to table`,
+            //   }),
+            // );
+
+            break;
+          }
+
+          case 'file_search': {
+            if (val?.file?.vector_store_id) {
+              tools.push(fileSearchTool(val.file.vector_store_id));
+            }
+
+            if (val?.youtube?.vector_store_id) {
+              tools.push(fileSearchTool(val.youtube.vector_store_id));
+            }
+
+            break;
+          }
+
+          case 'ai_agent': {
+            if (val.ai_agent_id) {
+              const agent_ret = await get_ai_agents({ _id: val.ai_agent_id });
+              if (agent_ret.code > -1) {
+                const agent_doc = agent_ret.data;
+
+                const agent = new Agent({
+                  name: agent_doc.agent_name,
+                  instructions: agent_doc.agent_instructions,
+                });
+
+                tools.push(
+                  agent.asTool({
+                    toolName: agent_doc.agent_name,
+                    toolDescription: agent_doc.agent_instructions,
+                  }),
+                );
+              }
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      }
+      // if (!tools.length) continue;
+
+      list.push(
+        new Agent({
+          name: ai_agent_doc._id,
+          instructions: ai_agent_doc.agentConfig.agent_instructions,
+          model,
+          tools,
+          metadata: {
+            agent_id: ai_agent_doc._id,
+            ts: Date.now(),
+          },
+          tool_resources,
+          modelSettings,
+        }),
+      );
+    }
+    //tell me more on xuda
+    // debugger;
+
+    return list;
+  };
+
+  try {
+    // if (reference_type === 'agent') {
+    // } else {
+    const runner = new Runner();
+    let _agent;
+    // 2. Build specialist agents list
+
+    const agents = await get_agents();
+
+    if (reference_type === 'ai_agents') {
+      _agent = agents[0];
+
+      try {
+        let agent_doc = await project_db.get(reference_id);
+        agent_doc.ts = Date.now();
+        const save_ret = await project_db.insert(agent_doc);
+      } catch (err) {}
+    } else {
+      // 3. Build triage agent that can hand off
+      _agent = new Agent({
+        name: 'Triage Agent',
+        instructions: 'You are a triage router. Decide which specialist should answer. If general, answer yourself. use web search only as last option',
+        model,
+        handoffs: agents, // this lets triageAgent forward to other agents
+      });
+
+      // 4. Run the triage agent with conversation memory
+      // Runner.runSync / Runner.run depending on your SDK.
+      // We pass { conversationId } so it can keep context across turns.
+
+      // const runner = new Runner();
+    }
+
+    const output = await runner.run(_agent, prompt, {
+      conversationId: conversation_id,
+      context,
+    });
+    // }
+    try {
+      const obj = { id: output?.output?.[0]?.id, ts: Date.now(), usage: { inputTokens: output.state._context.usage.inputTokens, outputTokens: output.state._context.usage.outputTokens }, ai_agent_id: output.state._currentAgent.name };
+      conversation_doc.ts = Date.now();
+      conversation_doc.messages.push(obj);
+      await project_db.insert(conversation_doc);
+
+      if (!conversation_exist) {
+        setTimeout(async () => {
+          // Ask GPT for title
+          const title = await submit_chat_gpt_prompt({
+            prompt: `create title for the prompt return 5 words result maximum text only without options : ${prompt}`,
+            model: 'gpt-5-nano',
+          });
+
+          conversation_doc = await project_db.get(conversation_id);
+          conversation_doc.title = title.data;
+
+          await project_db.insert(conversation_doc);
+          update_thumbnail('conversation', conversation_doc, uid);
+        }, 2500);
+      } else {
+        if (!conversation_doc.base64 && (!conversation_doc.thumbnail_request_ts || Date.now() - conversation_doc.thumbnail_request_ts > 120000)) {
+          update_thumbnail('conversation', conversation_doc, uid);
+        }
+      }
+    } catch (error) {
+      debugger;
+    }
+    // }
+
+    return {
+      code: 4,
+      data: {
+        conversation_doc,
+        response: output.output, // output.finalOutput ?? output.output ?? output, // depends on SDK shape
+      },
+    };
+  } catch (err) {
+    debugger;
+    return { code: -4, data: err.message || String(err) };
+  }
+};
+
+export const submit_chat_gpt_prompt = async function (req) {
+  const { model = 'gpt-5-mini', prompt } = req;
+  try {
+    const response = await client.responses.create({
+      model,
+      input: prompt,
+    });
+
+    return { code: 5, data: response.output_text };
+  } catch (err) {
+    return { code: -5, data: err.message };
+  }
+};
+
+export const create_studio_app = async function (subject) {
+  try {
+    let prompt = `
+    
+    1. list all tables and screens to build an ${subject} app.
+    2. return object array for each item (name,type,description) 
+    
+    
+    `;
+
+    const data = await submit_chat_gpt_prompt({ prompt });
+
+    return { code: 6, data };
+  } catch (err) {
+    return { code: -6, data: err.message };
+  }
+};
+
+async function fineTuneWithMultipleFiles(datasetPaths, baseModel = 'gpt-4o-mini') {
+  try {
+    console.log('📤 Uploading datasets...');
+
+    // Step 1. Upload all JSONL files in parallel
+    const uploadedFiles = await Promise.all(
+      datasetPaths.map(async (filePath) => {
+        const file = await openai.files.create({
+          file: fs.createReadStream(path.resolve(filePath)),
+          purpose: 'fine-tune',
+        });
+        console.log(`✅ Uploaded: ${file.filename} → ID: ${file.id}`);
+        return file.id;
+      }),
+    );
+
+    // Step 2. Create fine-tuning job with multiple training files
+    console.log(`🚀 Creating fine-tuning job for ${baseModel}...`);
+    const fineTuneJob = await openai.fineTuning.jobs.create({
+      training_files: uploadedFiles.map((id) => ({ file_id: id })), // <-- multiple files here
+      model: baseModel,
+    });
+
+    console.log(`📌 Fine-tuning job created: ${fineTuneJob.id}`);
+
+    // Step 3. Poll job status until training completes
+    let status = fineTuneJob.status;
+    while (status === 'pending' || status === 'running') {
+      console.log(`⏳ Job status: ${status}...`);
+      await new Promise((resolve) => setTimeout(resolve, 10000));
+
+      const updatedJob = await openai.fineTuning.jobs.retrieve(fineTuneJob.id);
+      status = updatedJob.status;
+    }
+
+    // Step 4. Check final status
+    if (status === 'succeeded') {
+      console.log('🎉 Fine-tuning completed successfully!');
+      console.log(`🆕 Fine-tuned model: ${fineTuneJob.fine_tuned_model}`);
+      return fineTuneJob.fine_tuned_model;
+    } else {
+      throw new Error(`❌ Fine-tuning failed: ${status}`);
+    }
+  } catch (error) {
+    console.error('⚠️ Fine-tuning error:', error);
+    throw error;
+  }
+}
+
+const create_image = async function (prompt, model = 'gpt-image-1-mini', size = '1024x1024', n = 1) {
+  try {
+    const response = await client.images.generate({
+      model,
+      prompt,
+      size,
+      n,
+    });
+
+    // Try to extract base64 directly
+    const imgObj = response.data?.[0];
+    if (!imgObj) throw new Error('No image returned from OpenAI');
+
+    // different SDK builds call it slightly differently, so normalize:
+    const rawBase64 = imgObj.b64_json || imgObj.image_base64 || imgObj.base64 || imgObj.data || null;
+
+    if (!rawBase64) {
+      // Fallback: if we *do* have a URL (some builds give both),
+      // then we can download it.
+      if (imgObj.url) {
+        const res = await fetch(imgObj.url);
+        if (!res.ok) {
+          throw new Error(`Failed to fetch image URL: ${res.status} ${res.statusText}`);
+        }
+        const arrayBuffer = await res.arrayBuffer();
+        const fullImgBuffer = Buffer.from(arrayBuffer);
+
+        // Resize to 128x128
+        const resized = await sharp(fullImgBuffer).resize(128, 128).toFormat('png').toBuffer();
+
+        return resized.toString('base64');
+      }
+
+      throw new Error('No base64 and no URL in image response');
+    }
+
+    // We got base64 from the API, so no extra fetch needed
+    const fullImgBuffer = Buffer.from(rawBase64, 'base64');
+
+    // Resize to 128x128
+    const resized = await sharp(fullImgBuffer).resize(128, 128).toFormat('png').toBuffer();
+
+    const thumbnailBase64 = resized.toString('base64');
+    return thumbnailBase64;
+  } catch (err) {
+    console.error('create_image error:', err);
+    return '';
+  }
+};
+
+const get_ai_doc = async function (req) {
+  let { uid, _id } = req;
+
+  const project_db = await get_account_project_db(uid);
+  try {
+    let data = await project_db.get(_id);
+    if (data?.studio_meta?.createdByUid !== uid) delete data.agentConfig; //throw new Error('doctype not supported');
+    return { code: 7, data };
+  } catch (err) {
+    return { code: -7, data: err.message };
+  }
+
+  // const db = get_xuda_couch('xuda_contacts');
+
+  // try {
+  //   let data = await db.get(_id);
+  //   if (!['ai_agent', 'chat_conversation'].includes(data.docType)) throw new Error('doctype not supported');
+  //   return { code: 1, data };
+  // } catch (err) {
+  //   return { code: -1, data: err.message };
+  // }
+};
+
+export const get_ai_agents = async function (req) {
+  let { uid, _id } = req;
+
+  try {
+    const project_db = await get_account_project_db(uid);
+
+    if (_id) return await get_ai_doc({ _id, uid });
+
+    const user_agents = await project_db.view('xuda', 'studio_docs_by_type', {
+      key: 'ai_agent',
+      include_docs: true,
+    });
+
+    return { code: 8, data: { docs: user_agents.rows.map((row) => row.value) } };
+  } catch (err) {
+    return { code: -8, data: err.message };
+  }
+};
+
+export const delete_ai_agent = async function (req) {
+  let { agent_id, uid } = req;
+
+  const project_db = await get_account_project_db(uid);
+
+  try {
+    let agent_doc = await project_db.get(agent_id);
+    agent_doc.stat = 4;
+    agent_doc.ts = Date.now();
+    const data = await project_db.insert(agent_doc);
+
+    for (const [key, val] of Object.entries(agent_doc?.agentConfig?.agent_tools || [])) {
+      const file_id = val?.youtube?.file_id || val?.file?.file_id;
+      const vector_store_id = val?.youtube?.vector_store_id || val?.file?.vector_store_id;
+      if (file_id) {
+        if (vector_store_id) {
+          const deletedVectorStoreFile = await client.vectorStores.files.delete(file_id, { vector_store_id });
+        }
+        await client.files.delete(file_id);
+      }
+    }
+
+    return { code: 9, data };
+  } catch (err) {
+    return { code: -9, data: err.message };
+  }
+
+  // const db = get_xuda_couch('xuda_contacts');
+  // try {
+  //   let agent_doc = await db.get(agent_id);
+  //   agent_doc.stat = 4;
+  //   agent_doc.ts = Date.now();
+  //   const data = await db.insert(agent_doc);
+
+  //   return { code: 1, data };
+  // } catch (err) {
+  //   return { code: -1, data: err.message };
+  // }
+};
+
+export const delete_mini_app = async function (req) {
+  let { prog_id, uid } = req;
+
+  const project_db = await get_account_project_db(uid);
+
+  try {
+    let prog_doc = await project_db.get(prog_id);
+    prog_doc.stat = 4;
+    prog_doc.ts = Date.now();
+    const data = await project_db.insert(prog_doc);
+
+    return { code: 29, data };
+  } catch (err) {
+    return { code: -29, data: err.message };
+  }
+};
+
+export const update_ai_agent = async function (req) {
+  let { agent_id, agentConfig, uid } = req;
+
+  const project_db = await get_account_project_db(uid);
+
+  try {
+    let agent_doc = await project_db.get(agent_id);
+
+    agent_doc.ts = Date.now();
+    agent_doc.agentConfig = agentConfig;
+
+    agent_doc.studio_meta.agent_image = agentConfig.agent_image;
+
+    const data = await project_db.insert(agent_doc);
+
+    update_thumbnail('ai_agent', agent_doc, uid);
+    upload_agent_files(uid, agent_doc);
+    return { code: 10, data };
+  } catch (err) {
+    return { code: -10, data: err.message };
+  }
+};
+
+export const get_apps = async function (req) {
+  let { uid, _id } = req;
+
+  try {
+    const project_db = await get_account_project_db(uid);
+
+    if (_id) return await get_ai_doc({ _id, uid });
+
+    const user_agents = await project_db.view('xuda', 'studio_mini_apps', {
+      include_docs: true,
+    });
+
+    return { code: 11, data: { docs: user_agents.rows.map((row) => row.value) } };
+  } catch (err) {
+    return { code: -11, data: err.message };
+  }
+};
+
+const getExtension = function (filename) {
+  return path.extname(filename).toLowerCase();
+};
+
+const upload_agent_files = async function (uid, agent_doc) {
+  let { agentConfig } = agent_doc;
+  for await (let tool of agentConfig.agent_tools || []) {
+    if (tool.type === 'file_search') {
+      if (!_.isEmpty(tool.file)) {
+        if (!tool.file.file_id) {
+          const file_ext = getExtension(tool.file.name);
+
+          switch (file_ext) {
+            case 'mp3':
+            case 'mp4':
+              await save_agent_status(uid, agent_doc._id, 2, agentConfig);
+              const file_stream = await get_drive_file_stream(tool.file.name);
+              const transcript = await transcribe(file_stream);
+
+              const file = new File([Buffer.from(transcript, 'utf8')], tool.file.name, {
+                type: 'text/plain',
+              });
+
+              // const stream = textToStream(transcript);
+              const uploadedFile = await client.files.create({
+                file,
+                purpose: 'assistants',
+              });
+              tool.file.file_id = uploadedFile.id;
+
+              break;
+
+            default:
+              tool.file.file_id = await upload_file_to_openai_storage(tool.file.name);
+              break;
+          }
+
+          if (!tool.file.vector_file_id) {
+            const ret = await client.vectorStores.files.create(_conf.OPENAI_VECTOR_STORE_ID, {
+              file_id: tool.file.file_id,
+            });
+            tool.file.vector_store_id = ret.vector_store_id;
+          }
+          await save_agent_status(uid, agent_doc._id, 3, agentConfig);
+        }
+      }
+
+      if (!_.isEmpty(tool?.youtube)) {
+        if (!_.isEmpty(tool?.youtube.url)) {
+          if (!tool.youtube.file_id) {
+            await save_agent_status(uid, agent_doc._id, 2, agentConfig);
+            tool.youtube.file_name = await download_yt_audio(tool.youtube.url);
+
+            const tmp_file = '/tmp/' + tool.youtube.file_name;
+            const file_stream = fs.createReadStream(tmp_file);
+            const transcript = await transcribe(file_stream);
+            const file = new File([Buffer.from(transcript, 'utf8')], tool.youtube.file_name, {
+              type: 'text/plain',
+            });
+            // const stream = textToStream(transcript);
+
+            const uploadedFile = await client.files.create({
+              file,
+              purpose: 'assistants',
+            });
+
+            tool.youtube.file_id = uploadedFile.id;
+
+            if (!tool.youtube.vector_file_id) {
+              const ret = await client.vectorStores.files.create(_conf.OPENAI_VECTOR_STORE_ID, {
+                file_id: tool.youtube.file_id,
+              });
+              tool.youtube.vector_store_id = ret.vector_store_id;
+            }
+            await save_agent_status(uid, agent_doc._id, 3, agentConfig);
+
+            // stream.on('end', () => {
+            //   unlink(tmp_file).catch(console.error);
+            // });
+          }
+        }
+      }
+    }
+  }
+};
+
+const validate_ai_agent = async function (req) {
+  //  "tool_type": {
+  //           "name": "Tool Type",
+  //           "description": "",
+  //           "type": "array",
+  //           "enum": [
+  //             "web_search",
+  //             "file_search",
+  //             "program",
+  //             "mcp",
+  //             "plugin",
+  //             "ai_agent",
+  //             "table",
+  //             "image_generate"
+  //           ],
+  //           "mandatory": true
+  //         }
+};
+
+const save_agent_status = async function (uid, agent_id, stat, agentConfig) {
+  const project_db = await get_account_project_db(uid);
+
+  try {
+    let agent_doc = await project_db.get(agent_id);
+    agent_doc.ts = Date.now();
+    agent_doc.stat = stat;
+    agent_doc.agentConfig = agentConfig;
+    const data = await project_db.insert(agent_doc);
+
+    return { code: 12, data };
+  } catch (err) {
+    return { code: -12, data: err.message };
+  }
+};
+
+export const create_ai_agent = async function (req) {
+  const { agentConfig, uid } = req;
+
+  const { account_project_id, account_info } = await get_account_object(uid);
+
+  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_project_id, parentId: 'ai_agents' };
+    var agent_doc = createDoc(param);
+    agent_doc.agentConfig = agentConfig;
+
+    // const data = await db.insert(agent_doc);
+    const project_db = await get_account_project_db(uid);
+    const data = await project_db.insert(agent_doc);
+
+    update_thumbnail('ai_agent', agent_doc, uid);
+    upload_agent_files(uid, agent_doc);
+    return { code: 13, data };
+  } catch (err) {
+    return { code: -13, data: err.message };
+  }
+};
+
+const update_thumbnail = function (type, doc, uid) {
+  let prompt = '';
+
+  setTimeout(async () => {
+    try {
+      const project_db = await get_account_project_db(uid);
+      let db_doc = await project_db.get(doc._id);
+
+      switch (type) {
+        case 'ai_agent': {
+          if (db_doc.studio_meta.agent_image_base64 && db_doc.properties.menuName === db_doc.properties.menuName) return;
+
+          prompt = `create image:
+
+        Overview
+        The image portrays a futuristic humanoid or abstract AI entity designed to represent a specific role — such as a sales assistant, data analyst, creative advisor, or search agent. The scene blends cutting-edge technology with an artistic or cinematic atmosphere, creating a visual narrative of intelligence, precision, and innovation.
+
+        Subject
+
+        The central figure (or core system) embodies artificial intelligence personified.
+        It may appear as a humanoid robot, a digital avatar, or a symbolic interface made of light and code. The features — whether facial, mechanical, or abstract — convey awareness, focus, and adaptability. The subject’s posture and expression (if applicable) suggest calm confidence, curiosity, or analytical engagement.
+
+        🕶 Appearance
+
+        The AI’s form is designed to match its role:
+
+        
+
+        ${doc.name}
+
+        Reflective or metallic textures emphasize intelligence and sophistication, while the surrounding lighting harmonizes with the AI’s color scheme to project its purpose and tone.
+
+        Interface & Interaction
+
+        The AI often interacts with floating holographic or projected interfaces, symbolizing its digital workspace.
+        Common elements include:
+
+        Graphs, data panels, dashboards, or search bars.
+
+        Abstract geometric shapes representing logic or neural activity.
+
+        Light trails or motion blur effects suggesting processing or communication.
+
+        The AI engaging with gestures — pointing, typing in mid-air, or scanning visual elements.
+
+        These details illustrate the agent’s domain: sales forecasting, query resolution, creative generation, or data interpretation.
+
+        Environment & Lighting
+
+        The environment bridges the real and virtual worlds — a fusion of architecture, code, and energy.
+        It may include:
+
+        Corporate or futuristic interiors (clean walls, neon highlights, glass surfaces).
+
+        Abstract digital landscapes filled with data grids or holographic streams.
+
+        Natural or surreal elements (roses, water reflections, sky motifs) that humanize the setting.
+
+        Lighting contrasts — blue/orange, violet/silver, gold/teal — create emotional tension between logic and inspiration.
+
+        Mood & Style
+
+        The overall mood is visionary and intelligent, evoking trust and advancement.
+        The visual style can vary:
+
+        Cyber-surreal: dreamlike, poetic, glowing.
+
+        Corporate-futuristic: clean, efficient, minimalistic.
+
+        Cinematic-AI realism: detailed, photorealistic, story-driven.
+
+        Composition centers the AI or interface as the focal point, surrounded by hints of motion, light, and context. The image symbolizes the fusion of human creativity and machine intelligence.`;
+          db_doc.studio_meta.thumbnail_request_ts = Date.now();
+          const base64 = await create_image(prompt);
+          db_doc.studio_meta.agent_image_base64 = base64;
+
+          break;
+        }
+        case 'conversation': {
+          prompt = `create image: ${doc.title}`;
+          db_doc.thumbnail_request_ts = Date.now();
+          const base64 = await create_image(prompt);
+          db_doc.base64 = base64;
+          break;
+        }
+
+        case 'mini_app': {
+          prompt = `create image: ${db_doc.properties.menuName}`;
+          db_doc.studio_meta.thumbnail_request_ts = Date.now();
+          const base64 = await create_image(prompt);
+          db_doc.studio_meta.agent_image_base64 = base64;
+          break;
+        }
+
+        default:
+          prompt = '';
+          break;
+      }
+
+      const save_ret = await project_db.insert(db_doc);
+    } catch (error) {
+      debugger;
+    }
+  }, 500);
+};
+const get_drive_file_stream = async function (file_path) {
+  const filename = path.basename(file_path);
+  const db = get_xuda_couch('xuda_drive');
+  const ret = await db.find({
+    selector: {
+      docType: 'user_drive',
+      type: 'file',
+      file_path: path.dirname(file_path) === '.' ? '/' : path.dirname(file_path),
+      originalname: filename,
+      stat: 3,
+    },
+  });
+  const doc = ret?.docs?.[0];
+  const _region = process.env.XUDA_HOSTNAME; // "eu.xuda.io"; //
+  let file_location = doc?.bucket?.[_region]?.Location;
+
+  try {
+    // const res = await fetch(file_location);
+
+    let response;
+    try {
+      response = await fetch(file_location);
+    } catch (error) {
+      // fix bucket bug
+      try {
+        response = await fetch(file_location.replace(/([^\/]+)\/([^\/]+)\/(.*)/, 'https://$2.$1/$3'));
+      } catch (error) {
+        throw error;
+      }
+    }
+
+    if (!response.ok) throw new Error(`Failed to download file: ${response.statusText}`);
+
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+
+    const tmp_file = '/tmp/' + filename;
+    await writeFile(tmp_file, buffer);
+    // 3️⃣ Upload file to OpenAI
+    const stream = fs.createReadStream(tmp_file);
+
+    // unlink(tmp_file);
+
+    stream.on('end', () => {
+      unlink(tmp_file).catch(console.error);
+    });
+
+    return stream;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const transcribe = async function (stream) {
+  try {
+    // const stream = await get_drive_file_stream(filePath);
+    // debugger;
+    const resp = await client.audio.transcriptions.create({
+      // Choose one model:
+      model: 'whisper-1', // or "gpt-4o-transcribe", "whisper-1"
+      file: stream, //fs.createReadStream(filePath),
+      // Optional:
+      response_format: 'text', // "text" | "json" | "verbose_json" | "srt" | "vtt"
+      language: 'en', // hint language (ISO 639-1), e.g. "he" for Hebrew
+      // temperature: 0           // lower = more literal
+    });
+
+    console.log(resp); // or resp for JSON formats
+    return resp;
+  } catch (error) {
+    debugger;
+  }
+};
+
+const upload_file_to_openai_storage = async function (file_path) {
+  // const filename = path.basename(file_path);
+  // const db = get_xuda_couch('xuda_drive');
+  // const ret = await db.find({
+  //   selector: {
+  //     docType: 'user_drive',
+  //     type: 'file',
+  //     file_path: path.dirname(file_path) === '.' ? '/' : path.dirname(file_path),
+  //     originalname: filename,
+  //     stat: 3,
+  //   },
+  // });
+  // const doc = ret?.docs?.[0];
+  // const _region = process.env.XUDA_HOSTNAME; // "eu.xuda.io"; //
+  // let file_location = doc?.bucket?.[_region]?.Location;
+
+  try {
+    // const res = await fetch(file_location);
+
+    // if (!res.ok) throw new Error(`Failed to download file: ${res.statusText}`);
+
+    // const arrayBuffer = await res.arrayBuffer();
+    // const buffer = Buffer.from(arrayBuffer);
+
+    // const tmp_file = '/tmp/' + filename;
+    // await writeFile(tmp_file, buffer);
+    // 3️⃣ Upload file to OpenAI
+    // const stream = fs.createReadStream(tmp_file);
+
+    const stream = await get_drive_file_stream(file_path);
+
+    const uploadedFile = await client.files.create({
+      file: stream,
+      purpose: 'assistants',
+    });
+
+    // const file = await toFile(stream, filename, { purpose: 'assistants' });
+    // debugger;
+    // const uploadedFile = await client.vectorStores.files.create(_conf.OPENAI_VECTOR_STORE_ID, {
+    //   file_id: tmp_file,
+    // });
+
+    console.log('📂 Uploaded file:', uploadedFile.id);
+    unlink(tmp_file);
+    return uploadedFile.id;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const get_account_object = async function (uid) {
+  const db = get_xuda_couch('xuda_accounts');
+  const account_obj = await db.get(uid);
+  return account_obj;
+};
+
+const get_account_project_id = async function (uid) {
+  const account_obj = await get_account_object(uid);
+  return account_obj.account_project_id;
+};
+
+const get_account_project_db = async function (uid) {
+  const user_project_id = await get_account_project_id(uid);
+
+  const project_db = await get_project_db(user_project_id);
+  return project_db;
+};
+
+const get_app_obj = async function (app_id) {
+  const db = get_xuda_couch('xuda_master');
+  const app_obj = await db.get(app_id);
+  return app_obj;
+};
+
+const get_project_db = async function (app_id) {
+  const app_obj = await get_app_obj(app_id);
+  const project_db = get_xuda_couch(app_obj.app_db_name);
+  return project_db;
+};
+
+const download_yt_audio = function (videoUrl) {
+  const extractVideoId = function (url) {
+    const regex = /(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([^&\n?#]+)/;
+    const match = url.match(regex);
+    return match ? match[1] : null;
+  };
+
+  const filename = extractVideoId(videoUrl) + '.m4a';
+  const output = '/tmp/' + filename;
+  return new Promise((resolve, reject) => {
+    class AdvancedYouTubeDownloader {
+      constructor() {
+        this.retryCount = 0;
+        this.maxRetries = 3;
+        this.proxyList = [_conf.PROXY_HTTP_URL];
+        this.currentProxyIndex = 0;
+        this.usePuppeteerFallback = true;
+      }
+
+      async download(videoUrl) {
+        try {
+          console.log(`Starting download attempt ${this.retryCount + 1}`);
+          await this.downloadWithCurrentStrategy(videoUrl);
+          return filename;
+        } catch (error) {
+          console.error(`Attempt ${this.retryCount + 1} failed: ${error.message}`);
+
+          if (this.retryCount < this.maxRetries) {
+            this.retryCount++;
+            await this.delay(2000 * this.retryCount);
+            this.download(videoUrl);
+            return filename;
+          } else if (this.usePuppeteerFallback) {
+            console.log('All direct downloads failed, trying Puppeteer fallback...');
+            await this.downloadWithPuppeteer(videoUrl);
+            return filename;
+          } else {
+            throw new Error(`All download strategies failed`);
+          }
+        }
+      }
+
+      async downloadWithCurrentStrategy(videoUrl) {
+        const options = {
+          // Audio extraction and conversion
+          extractAudio: true,
+          audioFormat: 'mp3',
+          audioQuality: 9, // Lowest quality for smallest file size
+
+          // Force MP3 output with specific extension
+          output, //: '/tmp/%(title)s.mp3',
+
+          // Force conversion with low quality settings
+          postprocessorArgs: [
+            'ffmpeg:-c:a',
+            'libmp3lame',
+            '-q:a',
+            '9', // Lowest quality (0-9, where 9 is worst)
+            '-ac',
+            '1', // Mono audio
+            '-ar',
+            '22050', // Low sample rate
+            '-b:a',
+            '64k', // Low bitrate
+          ],
+
+          // Network options
+          noCheckCertificates: true,
+          noWarnings: true,
+          addHeader: this.getHeaders(),
+          retries: 2,
+          socketTimeout: 30000,
+
+          // Ensure we get audio formats
+          format: 'worstaudio/worst',
+
+          // Additional conversion flags
+          embedMetadata: true,
+          noOverwrites: true,
+        };
+
+        // Try with proxy first
+        const proxy = this.proxyList[this.currentProxyIndex];
+        if (proxy) {
+          options.proxy = proxy;
+          console.log(`Using proxy: ${proxy.split('@')[1]}`);
+        }
+
+        console.log('Starting MP3 conversion with options:', {
+          audioFormat: options.audioFormat,
+          audioQuality: options.audioQuality,
+          output: options.output,
+        });
+
+        const result = await youtubedl(videoUrl, options);
+        console.log('✅ MP3 download successful!');
+        this.retryCount = 0;
+        return result;
+      }
+
+      async downloadWithPuppeteer(videoUrl) {
+        console.log('Using Puppeteer to bypass bot detection...');
+
+        const browser = await puppeteer.launch({
+          headless: true,
+          args: ['--no-sandbox', '--disable-setuid-sandbox'],
+        });
+
+        try {
+          const page = await browser.newPage();
+          await page.setUserAgent(this.getHeaders()[0].split(':')[1]);
+
+          console.log('Navigating to YouTube...');
+          await page.goto(videoUrl, {
+            waitUntil: 'networkidle2',
+            timeout: 60000,
+          });
+
+          await page.waitForTimeout(5000);
+
+          // Check if we successfully bypassed bot detection
+          const pageTitle = await page.title();
+          if (pageTitle.includes('bot') || pageTitle.includes('Verify')) {
+            throw new Error('Bot detection still active after Puppeteer');
+          }
+
+          const currentUrl = page.url();
+          console.log('Successfully accessed video URL:', currentUrl);
+          await browser.close();
+
+          // Now download with the verified URL using enhanced MP3 settings
+          return await youtubedl(currentUrl, {
+            extractAudio: true,
+            audioFormat: 'mp3',
+            audioQuality: 9,
+            output, //: '/tmp/%(title)s.mp3',
+            noCheckCertificates: true,
+            noWarnings: true,
+            postprocessorArgs: ['ffmpeg:-c:a', 'libmp3lame', '-q:a', '9', '-ac', '1', '-ar', '22050', '-b:a', '64k'],
+            format: 'worstaudio/worst',
+          });
+        } catch (error) {
+          await browser.close();
+          throw error;
+        }
+      }
+
+      // Alternative method for guaranteed MP3 conversion
+      async downloadAsMP3(videoUrl) {
+        const options = {
+          // Method 1: Direct format selection for worst audio quality
+          format: 'worstaudio[ext=m4a]/worstaudio/bestaudio[ext=m4a]/bestaudio',
+
+          // Method 2: Extract and convert
+          extractAudio: true,
+          audioFormat: 'mp3',
+          audioQuality: 9,
+
+          // Force MP3 output
+          output, //: '/tmp/%(title)s.mp3',
+
+          // Enhanced conversion settings
+          postprocessorArgs: 'ffmpeg:-c:a libmp3lame -q:a 9 -ac 1 -ar 22050 -b:a 64k',
+
+          // Network
+          noCheckCertificates: true,
+          noWarnings: true,
+          addHeader: this.getHeaders(),
+          socketTimeout: 30000,
+        };
+
+        const proxy = this.proxyList[this.currentProxyIndex];
+        if (proxy) {
+          options.proxy = proxy;
+        }
+
+        console.log('Using enhanced MP3 conversion method...');
+        return await youtubedl(videoUrl, options);
+      }
+
+      // Method to check what's being downloaded (for debugging)
+      async debugDownload(videoUrl) {
+        console.log('=== DEBUG MODE ===');
+
+        try {
+          // First, list available formats
+          const formats = await youtubedl(videoUrl, {
+            listFormats: true,
+            proxy: this.proxyList[this.currentProxyIndex],
+            noCheckCertificates: true,
+          });
+          console.log('Available formats:', formats);
+
+          // Then try download
+          return await this.downloadAsMP3(videoUrl);
+        } catch (error) {
+          console.error('Debug failed:', error);
+          throw error;
+        }
+      }
+
+      rotateProxy() {
+        this.currentProxyIndex = (this.currentProxyIndex + 1) % this.proxyList.length;
+        console.log(`Rotated to proxy index: ${this.currentProxyIndex}`);
+      }
+
+      getHeaders() {
+        return ['user-agent:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36', 'accept:*/*', 'accept-language:en-US,en;q=0.9', 'referer:https://www.youtube.com/'];
+      }
+
+      delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+    }
+
+    // Usage examples:
+    const downloader = new AdvancedYouTubeDownloader();
+
+    // Method 1: Regular download (recommended)
+    downloader
+      .download(videoUrl)
+      .then((result) => {
+        console.log('🎉 Download completed successfully!');
+        console.log('Result:', result);
+        let interval = setInterval(() => {
+          if (fs.existsSync(`/tmp/${result}`)) {
+            clearInterval(interval);
+            resolve(result);
+          }
+        }, 1000);
+      })
+      .catch((error) => {
+        console.error('💥 Final error:', error);
+        reject(error.message);
+      });
+  });
+};
+setTimeout(async () => {
+  const app_id = 'prj712ffdf5aa8adce6cedef988f9c12392'; //'prj3937cb6f9a31c8c7dea25055bba845b1'; //
+  const uid = 'd39126e0e2c51ffbd1aad10709fc8335';
+
+  // await init_studio_units();
+  let ret;
+  // await build_studio_table_tools(app_id);
+  // testTool(app_id, uid);
+  // ret = await download_yt_audio('https://www.youtube.com/watch?v=uSt5yLOWiNo');
+  // ret = await update_ai_agent({
+  //   uid: 'd39126e0e2c51ffbd1aad10709fc8335',
+  //   agent_id: '392_agn_ddbca7c25455',
+  //   agentConfig: {
+  //     agent_instructions: 'use app builder to build tables and programs',
+  //     agent_tools: [
+  //       {
+  //         type: 'app_builder',
+  //         name: 'app_builder',
+  //       },
+  //     ],
+  //     agent_name: 'Xuda App Builder',
+  //   },
+  // });
+  // ret = await client.vectorStores.files.create(_conf.OPENAI_VECTOR_STORE_ID, {
+  //   file_id: 'file-Rf9UzT1f7NVhTELypnbsBU',
+  // });
+  // ret = upload_file_to_openai_storage('/docxsite-bp.xlsx.pdf');
+  // ret = await transcribe('/AAA.mp3');
+  // ret = await transcribe('/B.mp4');
+  // ret = await upload_file_to_openai_storage('/AAA.mp3');
+  // ret = await create_image("'Generate an image of gray tabby cat hugging an otter with an orange scarf'");
+  // ret = await submit_chat_conversation({ prompt: 'my name is Boaz' });
+  // ret = await submit_chat_conversation({ prompt: 'what is my name', conversation_id: ret.data.conversation_doc._id });
+  // const ret = await create_studio_app('crm');
+  //   ret = await submit_chat_gpt_prompt({
+  //     prompt: `Use the formatting rules from the Xuda fine-tuned model.
+  // Generate a new Table Object JSON with the same schema learned in training.
+  // Don't modify _rev. Preserve screenshots array structure.`,
+  //     model: 'ft:gpt-4o-2024-08-06:xuda-io:xuda-table:CdYWfx0l', //'ft:gpt-4.1-nano-2025-04-14:xuda-io:xuda-table:CdXWxgir'
+  //   });
+  // const ret = await submit_agentic_studio_chat_gpt_prompt({ user_prompt: 'crm app', object_unit: 'app', uid, app_id });
+  // ret = await submit_agentic_studio_chat_gpt_prompt({ user_prompt: 'products', object_unit: 'table', uid, app_id });
+  // ret = await submit_agentic_studio_chat_gpt_prompt({ user_prompt: 'test3', object_unit: 'folder', uid, app_id });
+  // ret = await submit_agentic_studio_chat_gpt_prompt({ user_prompt: 'contact contact form', object_unit: 'component', uid, app_id });
+  // ret = await submit_agentic_studio_chat_gpt_prompt({ user_prompt: 'get data from tasks by task id', object_unit: 'get_data', uid, app_id });
+
+  ret = await test_plugin(app_id, uid);
+  console.log(ret);
+
+  // init({}, {}, _, true, null, null, UglifyJS, JSON5, _conf, false, z);
+  // const schema = get_zod_schema('component');
+
+  // const db = get_xuda_couch('xuda_master');
+  // const app_obj = await db.get(app_id);
+  // const project_db = get_xuda_couch(app_obj.app_db_name);
+  // const doc = await project_db.get('5b1_cmp_313d53e56c2d');
+
+  ////////////////////
+  // let err_ret = [];
+  // const addValidationError = (code, data) => {
+  //   err_ret.push({
+  //     code,
+  //     data,
+  //     type: 'E',
+  //     category: 'document',
+  //     structure_error: true,
+  //   });
+  // };
+  //////////////////
+
+  // const result = schema.safeParse({});
+  // if (!result.success) {
+  //   console.log(result.error.errors); // Array of error objects
+  //   result.error.errors.forEach((error) => {
+  //     // console.log(`Path: ${error.path}, Message: ${error.message}`);
+  //     const msg = `${error.message}: ${error.path}(${error.expected})`;
+  //     addValidationError('CHK_MSG_OBJ_GEN_000', msg);
+  //   });
+  //   console.log(err_ret);
+  // } else {
+  //   console.log('Validation succeeded:', result.data);
+  // }
+
+  // const jsonSchema = zodToJsonSchema(schema);
+  // // console.log(jsonSchema);
+  // console.log(JSON.stringify(jsonSchema, null, 2));
+
+  // console.log(
+  //   check(
+  //     createDoc({
+  //       uid: '11',
+  //       app_id: 'prj-444',
+  //       menuType: 'folder',
+  //       checkedInUserName: 'boaz',
+  //       parentId: '',
+  //     }),
+  //   ),
+  // );
+
+  // const vectorStore = await client.beta.vector_stores.create({
+  //   name: 'Xuda Docs Vector Store',
+  // });
+  // console.log('Vector Store ID:', vectorStore.id);
+  // console.log('OpenAI version:', (await import('openai/package.json')).version);
+  // console.log('has beta?', !!client.beta);
+  // console.log('has vector_stores?', !!client.beta?.vector_stores);
+  // console.log('keys on vector_stores:', Object.keys(client.beta?.vector_stores || {}));
+
+  // const vectorStore = await client.vectorStores.create({
+  //   name: 'Xuda Docs Vector Store',
+  // });
+  // console.log(vectorStore);
+}, 1000);
+
+// PROMPT                                                             OBJECT UNIT             OUTPUT
+//==================================================================  ====================    =====================
+// create customer table
+// fill 5 rows to customer table
+// describe the customer table
+// create router for the app
+// create form program and save the data in the customer table
+// generate 10 buttons using tailwind
+// describe the program
+// create crm app
+// change text color
+// fetch only new customers using mongo query
+// create dashboard program for crm app
+// find diffs between two objects
+
+///////////////////////
+
+async function testTool(app_id, uid) {
+  console.log('Testing tool with:', { app_id, uid, table_id: '392_tbl_47f0ac6059ca' });
+
+  try {
+    const input = { table_id: '392_tbl_47f0ac6059ca' };
+    const runContext = { context: { app_id, uid } };
+    const details = {};
+
+    console.log('Input:', JSON.stringify(input, null, 2));
+    console.log('RunContext:', JSON.stringify(runContext, null, 2));
+    debugger;
+    // CORRECT ORDER: input first, then runContext
+    const result = await get_studio_table_info_by_table_id_tool.invoke(
+      runContext, // 1st: context
+      input, // 2nd: parameters
+      details, // 3rd: optional
+    );
+
+    console.log('Tool test successful:', result);
+    return result;
+  } catch (error) {
+    console.error('Tool test failed:');
+    console.error('Error:', error.message);
+    throw error;
+  }
+}
+async function test_plugin(app_id, uid, plugin_name = '@xuda.io/xuda-library-plugin-studio-ai-app-builder', method = 'table_builder', dev = true, req = {}) {
+  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)}`);
+        resolve(plugin_resource_res);
+      } catch (err) {
+        console.error(err);
+        reject();
+      }
+    });
+  };
+
+  const get_fields_data = async function (fields, props) {
+    const get_property_value = async function (fieldIdP, val) {
+      var value = props[fieldIdP] || (typeof val.defaultValue === 'function' ? val?.defaultValue?.() : val?.defaultValue);
+
+      return cast(
+        val.type,
+        value,
+        (err) => {
+          throw new Error(err);
+        },
+        (err) => {},
+      );
+    };
+    var data_obj = {};
+    var return_code = 1;
+
+    for await (const [key, val] of Object.entries(fields)) {
+      data_obj[key] = await get_property_value(key, val);
+      if (!data_obj[key] && val.mandatory) {
+        return_code = -1;
+        throw new Error(`${key} is a mandatory field.`);
+      }
+    }
+    return data_obj;
+  };
+
+  console.log('Testing plugin with:', { app_id, uid });
+
+  try {
+    const app_obj = await get_app_obj(app_id);
+
+    const project_db = await get_project_db(app_id);
+    let plugin_doc;
+    try {
+      plugin_doc = await project_db.get(plugin_name);
+    } catch (error) {
+      throw new Error(`plugin_doc ${plugin_name} not found`);
+    }
+
+    const _plugin = app_obj.app_plugins_purchased[plugin_name];
+
+    if (!_plugin?.installed) {
+      throw new Error(`plugin ${plugin_name} not installed`);
+    }
+
+    const index = await get_plugin_resource(plugin_name, 'index.mjs');
+    const server = await get_plugin_resource(plugin_name, 'server.mjs');
+
+    const methods = index.methods;
+    if (methods && !methods[method]) {
+      throw new Error(`method ${method} not found`);
+    }
+    const prop_data = { prompt: 'build user table' };
+    const fields = await get_fields_data(methods[method].fields, prop_data);
+    const params = { ...fields, ...{ app_id, uid } };
+    const setup_doc = plugin_doc.setup || { OPENAI_API_KEY: _conf.OPENAI_API_KEY };
+
+    ///////////////////////
+    const execute_server_script = async function (req, app_id_reference, server_script, method, params, setup_doc) {
+      return new Promise(async (resolve, reject) => {
+        const app_plugins_path = path.join(_conf.plugins_drive_path, app_id_reference, 'node_modules');
+
+        process.on('uncaughtException', (err) => {
+          console.error('Asynchronous error caught.', err);
+        });
+        const resolve_local = function (e) {
+          resolve({ code: 1, data: e });
+        };
+
+        const reject_local = function (e) {
+          reject({ code: -1, data: e });
+          // reject(e.message);
+        };
+
+        try {
+          const script = new VMScript(`try{server_script.${method}(req,params,setup_doc,resolve,reject,process);}catch(e){ console.error(e); }`, { filename: app_plugins_path, dirname: app_plugins_path });
+          let vm = new NodeVM({
+            require: {
+              external: true,
+            },
+            sandbox: { process, params, setup_doc, resolve: resolve_local, reject: reject_local, req, server_script },
+            timeout: 60000,
+          });
+          return await vm.run(script, {
+            filename: app_plugins_path,
+            dirname: app_plugins_path,
+          });
+        } catch (err) {
+          console.error('Failed to execute script.', err);
+        }
+        // };
+      });
+    };
+
+    let ret_exec = await execute_server_script(req, app_id, server, method, params, setup_doc);
+    ///////////////
+
+    return ret_exec;
+  } catch (error) {
+    console.error('Testing plugin failed:');
+    console.error('Error:', error);
+    throw error;
+  }
+}