@xuda.io/ai_module 1.1.5617 → 1.1.5619

package/index copy 2.js

@@ -0,0 +1,2129 @@
+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';
+
+const { readFile, unlink, writeFile } = fs.promises;
+
+// global._common = JSON.parse(await fs.readFile(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.mjs'), '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 } 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';
+
+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 { 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 = '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' } });
+    for (const doc of ret.docs) {
+      studio_units[doc._id] = doc;
+    }
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+await init_studio_units();
+
+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) {
+    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 db = get_xuda_couch('xuda_master');
+      const app_obj = await db.get(e.app_id);
+      const project_db = get_xuda_couch(app_obj.app_db_name);
+      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 create_app_doc_tool = tool({
+  name: 'save project doc tool',
+  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) {
+    try {
+      const doc = JSON5.parse(e.doc);
+
+      const db = get_xuda_couch('xuda_master');
+      const app_obj = await db.get(e.app_id);
+      const project_db = get_xuda_couch(app_obj.app_db_name);
+
+      const result = await project_db.insert(doc);
+      console.log('create_app_doc_tool >>>> ', result);
+      return result;
+    } 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 db = get_xuda_couch('xuda_master');
+      const app_obj = await db.get(e.app_id);
+      const project_db = get_xuda_couch(app_obj.app_db_name);
+
+      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, uid, app_id } = req;
+    const model = 'ft:gpt-4o-2024-08-06:personal:xuda:CAbDtO0p'; // 'gpt-4o'; //'gpt-4.1'; //
+    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);
+
+    // 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 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 () {
+      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 () {
+      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 create_app_doc_tool if errors exist
+            4. Use create_app_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} 
+`;
+    };
+
+    const get_folder_instructions = function () {
+      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 create_app_doc_tool if errors exist
+            5. Use create_app_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[`studio_${object_unit}`].short}
+
+
+            ### Output ###
+            if success: {code:1,data:save_result}
+            if fail: {code:-1,data:error} 
+`;
+    };
+
+    const get_component_instructions = function () {
+      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 create_app_doc_tool if errors exist
+            4. Use create_app_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[`studio_${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 () {
+      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 create_app_doc_tool if errors exist
+            5. Use create_app_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[`studio_${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(),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, create_app_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()),
+                  }),
+                }),
+              ),
+              tableFields: z.array(
+                z.object({
+                  id: z.string(),
+                  data: z.object({
+                    field_id: z.string(),
+                  }),
+                  props: z.object({
+                    fieldType: z.string(),
+                  }),
+                }),
+              ),
+            }),
+          ),
+        },
+      },
+      folder: {
+        name: 'Folder builder',
+        instructions: get_folder_instructions(),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, create_app_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(),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, create_app_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(),
+        tools: [get_user_name_tool, create_initial_studio_doc_tool, check_studio_doc_tool, create_app_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 },
+      });
+
+      return result;
+    };
+
+    const result = await run(user_prompt, object_unit);
+
+    return { code: 1, data: result.finalOutput };
+  } catch (err) {
+    console.error('>>>>> AI:', err);
+    console.error('Cause:', err?.cause?.message);
+    return { code: -1, 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: 1, data: { conversation, ...conversation_doc } };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+
+  // try {
+  //   // const conversation = await client.conversations.retrieve(conversation_id);
+  //   const db = get_xuda_couch('xuda_contacts');
+  //   const conversation_doc = await db.get(conversation_id);
+  //   let conversation = await client.conversations.items.list(conversation_id, { limit, order, after });
+
+  //   return { code: 1, data: { conversation, ...conversation_doc } };
+  // } catch (err) {
+  //   return { code: -1, 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);
+
+    return { code: 1, data };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+
+  // const db = get_xuda_couch('xuda_contacts');
+  // try {
+  //   let opt = { selector: { docType: 'chat_conversation', uid, stat: 3 } };
+  //   if (reference_id) {
+  //     opt.selector.reference_id = reference_id;
+  //   }
+  //   const data = await db.find(opt);
+
+  //   return { code: 1, data };
+  // } catch (err) {
+  //   return { code: -1, 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);
+
+    return { code: 1, data };
+  } catch (err) {
+    return { code: -1, 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 { prompt, uid, reference_type, reference_id /* agent_mode not used here */ } = req;
+  let { conversation_id } = req;
+
+  const project_db = await get_account_project_db(uid);
+
+  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);
+
+    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;
+
+    // conversation_doc = {
+    //   _id: conversation_id,
+    //   docType: 'chat_conversation',
+    //   title: prompt.substr(0, 40),
+    //   date_created_ts: Date.now(),
+    //   ts: Date.now(),
+    //   stat: 3,
+    //   uid,
+    //   messages: [],
+    // };
+
+    // const ret_save = await db.insert(conversation_doc);
+  }
+
+  const get_agents = async function () {
+    const list = [];
+
+    // default/general Q&A agent
+    // list.push(
+    //   new Agent({
+    //     name: 'Default Agent',
+    //     instructions: 'Answer any general user question clearly and briefly.',
+    //     model,
+    //   }),
+    // );
+    // debugger;
+    let ai_agents_ret = {};
+    let modelSettings = {};
+
+    if (reference_type === 'agent') {
+      modelSettings = { toolChoice: 'required' };
+      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) {
+      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 '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 'file_search': {
+            if (val.file.vector_store_id) {
+              tools.push(fileSearchTool(val.file.vector_store_id));
+            }
+
+            // const vector_store_ids = val.files.map((file) => file.vector_store_id);
+            // if (vector_store_ids.length) {
+            //   for (const store_id of vector_store_ids) {
+            //     tools.push(fileSearchTool(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 === 'agent') {
+      _agent = agents[0];
+    } 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,
+    });
+    // }
+    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: 1,
+      data: {
+        conversation_doc,
+        response: output.output, // output.finalOutput ?? output.output ?? output, // depends on SDK shape
+      },
+    };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+// const get_agents = function () {
+//   let ret = [];
+
+//   // const default_agent = {
+//   //   name: 'Default agent',
+//   //   instructions: '',
+//   //   tools: [],
+//   //   model,
+//   // };
+
+//   ret.push(
+//     new Agent({
+//       name: 'Default agent',
+//       instructions: 'answer any question',
+//       model,
+//     }),
+//   );
+
+//   return ret;
+// };
+
+// export const submit_chat_conversation = async function (req) {
+//   const { prompt, uid, agent_mode } = req;
+//   let { conversation_id } = req;
+
+//   const db = get_xuda_couch('xuda_contacts');
+//   // let thread;
+//   let conversation_doc;
+//   try {
+//     if (!conversation_id) throw '';
+//     conversation_doc = await db.get(conversation_id);
+//   } catch (err) {
+//     conversation_doc = await client.conversations.create();
+
+//     // await client.beta.threads.create();
+//     // console.log('thread', thread);
+//     conversation_id = conversation_doc.id;
+
+//     let ret = await submit_chat_gpt_prompt({ prompt: `create title for the prompt 5 words max: ${prompt}` });
+//     conversation_doc = { _id: conversation_id, docType: 'chat_thread', title: ret.data, date_created_ts: Date.now(), uid };
+//     await db.insert(conversation_doc);
+//   }
+
+//   try {
+//     // await client.beta.threads.messages.create(conversation_id, {
+//     //   role: 'user',
+//     //   content: prompt,
+//     // });
+
+//     // const response = await submit_chat_gpt_prompt({ prompt });
+
+//     // const thread_res = await client.beta.threads.messages.create(conversation_id, {
+//     //   role: 'assistant',
+//     //   content: response.data,
+//     // });
+//     debugger;
+//     const agents = get_agents();
+
+//     const triageAgent = Agent.create({
+//       name: 'Triage Agent',
+//       instructions: `Help the user with their questions.`,
+//       handoffs: agents,
+//     });
+//     // const output = await run(triageAgent, prompt, { conversationId: conversation_id });
+//     const output = await run(triageAgent, prompt);
+//     debugger;
+//     return { code: 1, data: { conversation_doc, response: output } };
+//   } catch (err) {
+//     return { code: -1, data: err.message };
+//   }
+// };
+// export const submit_chat_conversation = async function (req) {
+//   const { prompt, uid } = req;
+//   let { thread_id } = req;
+
+//   const db = get_xuda_couch('xuda_contacts');
+//   // let thread;
+//   let thread_doc;
+//   try {
+//     if (!thread_id) throw '';
+//     thread_doc = await db.get(thread_id);
+//   } catch (err) {
+//     thread_doc = await client.beta.threads.create();
+//     // console.log('thread', thread);
+//     thread_id = thread_doc.id;
+
+//     let ret = await submit_chat_gpt_prompt({ prompt: `create title for the prompt 5 words max: ${prompt}` });
+//     thread_doc = { _id: thread_id, docType: 'chat_thread', title: ret.data, date_created_ts: Date.now(), uid };
+//     await db.insert(thread_doc);
+//   }
+
+//   try {
+//     await client.beta.threads.messages.create(thread_id, {
+//       role: 'user',
+//       content: prompt,
+//     });
+
+//     const response = await submit_chat_gpt_prompt({ prompt });
+
+//     const thread_res = await client.beta.threads.messages.create(thread_id, {
+//       role: 'assistant',
+//       content: response.data,
+//     });
+//     debugger;
+//     return { code: 1, data: { thread_doc, response: response.data } };
+//   } catch (err) {
+//     return { code: -1, data: err.message };
+//   }
+// };
+
+// get_chat_thread({ thread_id: 'what the weather in herzeliya' });
+
+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: 1, data: response.output_text };
+  } catch (err) {
+    return { code: -1, 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: 1, data };
+  } catch (err) {
+    return { code: -1, 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 MODEL_NAME = 'gpt-5.1-mini'; // or whatever model you want
+
+// export const submit_chat_conversation = async function (req) {
+//   const { prompt, uid, reference_type, reference_id /* agent_mode not used here */ } = req;
+//   let { conversation_id } = req;
+
+//   const db = get_xuda_couch('xuda_contacts');
+
+//   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 db.get(conversation_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;
+
+//     // conversation_doc = {
+//     //   _id: conversation_id,
+//     //   docType: 'chat_conversation',
+//     //   title: prompt.substr(0, 40),
+//     //   date_created_ts: Date.now(),
+//     //   ts: Date.now(),
+//     //   stat: 3,
+//     //   uid,
+//     //   messages: [],
+//     // };
+
+//     // const ret_save = await db.insert(conversation_doc);
+//   }
+
+//   const get_agents = async function () {
+//     const list = [];
+
+//     // default/general Q&A agent
+//     // list.push(
+//     //   new Agent({
+//     //     name: 'Default Agent',
+//     //     instructions: 'Answer any general user question clearly and briefly.',
+//     //     model,
+//     //   }),
+//     // );
+
+//     const ret = await get_ai_agents({ uid });
+
+//     for (const doc of ret.data.docs) {
+//       let tools = [];
+//       let tool_resources = {};
+//       for (const [key, val] of Object.entries(doc?.agent_tools || [])) {
+//         const { name, description } = val;
+//         switch (val.type) {
+//           case 'hosted_web_search': {
+//             tools.push(webSearchTool());
+//             break;
+//           }
+
+//           case 'web_search': {
+//             tools.push(
+//               tool({
+//                 name,
+//                 description,
+//                 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 'file_search': {
+//             const vector_store_ids = val.files.map((file) => file.vector_store_id);
+//             if (vector_store_ids.length) {
+//               for (const store_id of vector_store_ids) {
+//                 tools.push(fileSearchTool(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: doc._id,
+//           instructions: doc.agent_instructions,
+//           model,
+//           tools,
+//           metadata: {
+//             agent_id: doc._id,
+//             ts: Date.now(),
+//           },
+//           tool_resources,
+//         }),
+//       );
+//     }
+//     //tell me more on xuda
+//     // debugger;
+
+//     return list;
+//   };
+
+//   try {
+//     // 2. Build specialist agents list
+
+//     const agents = await get_agents();
+
+//     // 3. Build triage agent that can hand off
+//     const triageAgent = 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(triageAgent, prompt, {
+//       conversationId: conversation_id,
+//     });
+
+//     // // 5. Persist any new conversationId the runner returns (some SDKs will
+//     // // generate/stabilize it and give you output.conversationId)
+//     // if (output.conversationId && output.conversationId !== conversation_id) {
+//     //   conversation_id = output.conversationId;
+//     //   // patch couch doc _id if you want them aligned OR store mapping
+//     //   // If you can't change _id after insert, store mapping instead:
+//     //   conversation_doc.thread_ref = output.conversationId;
+//     //   await db.insert(conversation_doc);
+//     // }
+
+//     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 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 db.get(conversation_id);
+//           conversation_doc.title = title.data;
+
+//           await db.insert(conversation_doc);
+//           update_thumbnail('conversation', conversation_doc, 'title');
+//         }, 2500);
+//       }
+//     } catch (error) {
+//       debugger;
+//     }
+//     // }
+
+//     return {
+//       code: 1,
+//       data: {
+//         conversation_doc,
+//         response: output.output, // output.finalOutput ?? output.output ?? output, // depends on SDK shape
+//       },
+//     };
+//   } catch (err) {
+//     return { code: -1, data: err.message || String(err) };
+//   }
+// };
+
+// helper to build specialist agents
+
+const create_image_small = async function (prompt) {
+  try {
+    const response = await client.images.generate({
+      model: 'dall-e-2',
+      prompt,
+      size: '256x256',
+    });
+
+    const imageUrl = response.data[0].url;
+    const res = await fetch(imageUrl);
+    if (!res.ok) throw new Error(`Failed to fetch image: ${res.status}`);
+    const arrayBuffer = await res.arrayBuffer();
+    const imgBuffer = Buffer.from(arrayBuffer);
+
+    // Step 3. Resize down to 128×128 (fast, local)
+    const resized = await sharp(imgBuffer).resize(128, 128).toFormat('png').toBuffer();
+
+    const base64 = resized.toString('base64');
+
+    return base64;
+  } catch (err) {
+    console.error('create_image error:', err);
+    return '';
+  }
+};
+
+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) throw new Error('doctype not supported');
+    return { code: 1, data };
+  } catch (err) {
+    return { code: -1, 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 system_project_id = _conf.superuser_account_ids[0];
+    // const user_project_id = await get_account_project_id(uid);
+    // debugger;
+    // const db = get_xuda_couch('xuda_master');
+    // const app_obj = await db.get(user_project_id);
+    // const project_db = get_xuda_couch(app_obj.app_db_name);
+    // // const doc = await project_db.get('5b1_cmp_313d53e56c2d');
+    // // const user_agents = await db.find({ selector: { docType: 'ai_agent', stat: 3 } });
+    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: 1, data: { docs: user_agents.rows.map((row) => row.value) } };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+
+  // const db = get_xuda_couch('xuda_contacts');
+
+  // if (_id) return await get_ai_doc({ _id });
+
+  // try {
+  //   const user_agents = await db.find({ selector: { docType: 'ai_agent', agent_ownership_type: 'user', uid, stat: 3 } });
+  //   const system_agents = await db.find({ selector: { docType: 'ai_agent', agent_ownership_type: 'system', stat: 3 } });
+
+  //   return { code: 1, data: { docs: [...user_agents.docs, ...system_agents.docs] } };
+  // } catch (err) {
+  //   return { code: -1, 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);
+
+    return { code: 1, data };
+  } catch (err) {
+    return { code: -1, 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 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);
+    // doc._id = agent_doc._id;
+    // doc._rev = agent_doc._rev;
+    agent_doc.ts = Date.now();
+    agent_doc.agentConfig = agentConfig;
+
+    await upload_agent_files(agent_doc.agentConfig);
+
+    const data = await project_db.insert(agent_doc);
+
+    update_thumbnail('ai_agent', agent_doc, uid);
+    return { code: 1, data };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+
+  // const db = get_xuda_couch('xuda_contacts');
+  // try {
+  //   const agent_doc = await db.get(agent_id);
+  //   doc._rev = agent_doc._rev;
+  //   doc.ts = Date.now();
+
+  //   // for await (let tool of doc.agent_tools || []) {
+  //   //   if (tool.type === 'file_search' && tool?.files?.length) {
+  //   //     for await (let file of tool.files || []) {
+  //   //       if (!file.file_id) {
+  //   //         file.file_id = await upload_file_to_openai_storage(file.filename);
+  //   //         if (!file.vector_file_id) {
+  //   //           const ret = await client.vectorStores.files.create(_conf.OPENAI_VECTOR_STORE_ID, {
+  //   //             file_id: file.file_id,
+  //   //           });
+  //   //           file.vector_store_id = ret.vector_store_id;
+  //   //         }
+  //   //       }
+  //   //     }
+  //   //   }
+  //   // }
+
+  //   await upload_agent_files(doc);
+
+  //   const data = await db.insert(doc);
+
+  //   update_thumbnail('ai_agent', doc, 'agent_name');
+  //   return { code: 1, data };
+  // } catch (err) {
+  //   return { code: -1, data: err.message };
+  // }
+};
+
+const upload_agent_files = async function (agentConfig) {
+  for await (let tool of agentConfig.agent_tools || []) {
+    if (tool.type === 'file_search' && !_.isEmpty(tool.file)) {
+      if (!tool.file.file_id) {
+        tool.file.file_id = await upload_file_to_openai_storage(tool.file.name);
+        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;
+        }
+      }
+    }
+
+    // if (tool.type === 'file_search' && tool?.files?.length) {
+    //   for await (let file of tool.files || []) {
+    //     if (!file.file_id) {
+    //       file.file_id = await upload_file_to_openai_storage(file.filename);
+    //       if (!file.vector_file_id) {
+    //         const ret = await client.vectorStores.files.create(_conf.OPENAI_VECTOR_STORE_ID, {
+    //           file_id: file.file_id,
+    //         });
+    //         file.vector_store_id = ret.vector_store_id;
+    //       }
+    //     }
+    //   }
+    // }
+  }
+};
+
+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
+  //         }
+};
+
+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;
+
+    await upload_agent_files(agent_doc.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);
+
+    return { code: 1, data };
+  } catch (err) {
+    return { code: -1, 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.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.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;
+        }
+        default:
+          prompt = '';
+          break;
+      }
+
+      const save_ret = await project_db.insert(db_doc);
+
+      // const db = get_xuda_couch('xuda_contacts');
+
+      // let db_doc = await db.get(doc._id);
+      // if (db_doc.base64 && db_doc[prop] === doc[prop]) return;
+      // const base64 = await create_image(prompt);
+      // db_doc.base64 = base64;
+      // const save_ret = await db.insert(db_doc);
+    } catch (error) {
+      debugger;
+    }
+  }, 500);
+};
+
+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 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 db = get_xuda_couch('xuda_master');
+  const app_obj = await db.get(user_project_id);
+  const project_db = get_xuda_couch(app_obj.app_db_name);
+  return project_db;
+};
+
+setTimeout(async () => {
+  const app_id = 'prjac771215b7a70d86bc3a8435bb18c885'; //'prj3937cb6f9a31c8c7dea25055bba845b1'; //
+  const uid = 'd39126e0e2c51ffbd1aad10709fc8335';
+
+  // await init_studio_units();
+  let ret;
+  // ret = await update_ai_agent({
+  //   uid: 'd39126e0e2c51ffbd1aad10709fc8335',
+  //   agent_id: '392_agn_ddbca7c25457',
+  //   agentConfig: {
+  //     agent_instructions: 'docxsite business plan agent response with detailed answers  using bp',
+  //     agent_tools: [
+  //       {
+  //         type: 'file_search',
+  //         file: {
+  //           name: 'docxsite-bp.xlsx.pdf',
+  //           sizeInBytes: 250222,
+  //           size: '244.36 KB',
+  //           extension: 'pdf',
+  //           type: 'file',
+  //           access_link: 'https://dev.xuda.io/user-drive/undefined/drv_d39126e0e2c51ffbd1aad10709fc8335_3243be15c292843c9d0901904513cd1f.pdf',
+  //           is_archive: false,
+  //           path: '/',
+  //           date_created: 1761659838034,
+  //           date_modified: 1761659838034,
+  //           file_path: '/docxsite-bp.xlsx.pdf',
+  //           tags: [],
+  //         },
+  //         name: 'bp',
+  //       },
+  //     ],
+  //     agent_name: 'Docxsite bp',
+  //   },
+  // });
+
+  // ret = upload_file_to_openai_storage('/docxsite-bp.xlsx.pdf');
+  // 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: `what is xuda` });
+  // 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 });
+  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