@xuda.io/ai_module 1.1.5616 → 1.1.5618

package/index old.mjs

@@ -0,0 +1,423 @@
+// 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 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 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_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;
+    }
+  },
+});
+
+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;
+  }
+}