json-object-editor 0.10.521 → 0.10.622

package/server/plugins/chatgpt.js

@@ -0,0 +1,729 @@
+const OpenAI = require("openai");
+const { google } = require('googleapis');
+const path = require('path');
+// const { name } = require("json-object-editor/server/webconfig");
+
+function ChatGPT() {
+   // const fetch = (await import('node-fetch')).default;
+    //const openai = new OpenAI();
+    // Load the service account key JSON file
+    const serviceAccountKeyFile = path.join(__dirname, '../local-joe-239900-e9e3b447c70e.json');
+    const google_auth = new google.auth.GoogleAuth({
+        keyFile: serviceAccountKeyFile,
+        scopes: ['https://www.googleapis.com/auth/documents.readonly'],
+    });
+
+    var self = this;
+    this.async ={};
+    function coloredLog(message){
+        console.log(JOE.Utils.color('[chatgpt]', 'plugin', false), message);
+    }
+    //xx -setup and send a test prompt to chatgpt
+    //xx get the api key from joe settings
+
+    //get a prompt from id
+    //send the prompt to chatgpt
+    
+    //++get the cotnent of a file
+    //++send the content of a file to chatgpt
+    
+    //++ structure data
+    //++ save the response to an ai_repsonse
+        //create an ai_response
+        //store the content
+        //attach to the request
+        //store ids sent with the request
+    this.default = function(data, req, res) {
+        try {
+            var payload = {
+                params: req.params,
+                data: data
+            };
+        } catch (e) {
+            return { errors: 'plugin error: ' + e, failedat: 'plugin' };
+        }
+        return payload;
+    };
+    function getAPIKey() {
+        const setting = JOE.Utils.Settings('OPENAI_API_KEY');
+        if (!setting) throw new Error("Missing OPENAI_API_KEY setting");
+        return setting;
+      }
+    function getSchemaDef(name) {
+        if (!name) return { full: null, summary: null };
+        const full = JOE.Schemas && JOE.Schemas.schema && JOE.Schemas.schema[name];
+        const summary = JOE.Schemas && JOE.Schemas.summary && JOE.Schemas.summary[name];
+        return { full, summary };
+    }
+
+    // function newClient(){
+    //     var key = getAPIKey();
+    //     var c = new OpenAI({
+    //         apiKey: key, // This is the default and can be omitted
+    //       });
+    //     if(!c || !c.apiKey){
+    //         return { errors: 'No API key provided' };
+    //     }
+    //     return c;
+    // }
+    function newClient() {
+    return new OpenAI({ apiKey: getAPIKey() });
+    }
+    this.testPrompt= async function(data, req, res) {
+        try {
+            var payload = {
+                params: req.params,
+                data: data
+            };
+        } catch (e) {
+            return { errors: 'plugin error: ' + e, failedat: 'plugin' };
+        }
+        const client = newClient();
+        if(client.errors){
+            return { errors: client.errors };
+        }
+        try {
+            const chatCompletion = await client.chat.completions.create({
+                messages: [{ role: 'user', content: 'Tell me a story about JOE: the json object editor in under 256 chars.' }],
+                model: 'gpt-4o',
+            });
+            coloredLog(chatCompletion);
+            return {payload,chatCompletion,content:chatCompletion.choices[0].message.content};
+        } catch (error) {
+            if (error.status === 429) {
+                return { errors: 'You exceeded your current quota, please check your plan and billing details.' };
+            } else {
+                return { errors: 'plugin error: ' + error.message, failedat: 'plugin' };
+            }
+        }
+    }
+
+    this.sendInitialConsultTranscript= async function(data, req, res) {
+        coloredLog("sendInitialConsultTranscript");
+    //get the prompt object from the prompt id
+    //get the business object from the refrenced object id
+    //see if there is a initial_transcript_url property on that object
+    //if there is, get the content of the file
+    //send the content to chatgpt, with the template property of the prompt object
+    //get the response
+        try {
+            var payload = {
+                params: req.params,
+                data: data
+            };
+        } catch (e) {
+            return { errors: 'plugin error: ' + e, failedat: 'plugin' };
+        }
+        var businessOBJ = JOE.Data.business.find(b=>b._id == data.business);
+        var promptOBJ = JOE.Data.ai_prompt.find(p=>p._id == data.ai_prompt);
+
+
+        // See if there is an initial_transcript_url property on that object
+        const transcriptUrl = businessOBJ.initial_transcript_url;
+        if (!transcriptUrl) {   
+            return res.jsonp({ error: 'No initial transcript URL found' });
+        }
+
+        //Get the content of the file from Google Docs
+        const transcriptContent = await getGoogleDocContent(transcriptUrl);
+        if (!transcriptContent || transcriptContent.error) {
+            return res.jsonp({ error: (transcriptContent.error && transcriptContent.error.message)||'Failed to fetch transcript content' });
+        }
+        const tokenCount = countTokens(`${promptOBJ.template}\n\n${transcriptContent}`);
+        payload.tokenCount = tokenCount;
+        coloredLog("token count: "+tokenCount);
+            //return res.jsonp({tokens:tokenCount,content:transcriptContent});
+        // Send the content to ChatGPT, with the template property of the prompt object
+        const client = new OpenAI({
+            apiKey: getAPIKey(), // This is the default and can be omitted
+        });
+
+        const chatResponse = await client.chat.completions.create({
+            messages: [{ role: 'user', content: `${promptOBJ.template}\n\n${transcriptContent}` }],
+            model: 'gpt-4o',
+        });
+
+        // Get the response
+        const chatContent = chatResponse.choices[0].message.content;
+        const responseName = `${businessOBJ.name} - ${promptOBJ.name}`;
+        // Save the response
+        await saveAIResponse({
+            name:responseName,
+            business: data.business,
+            ai_prompt: data.ai_prompt,
+            response: chatContent,
+            payload,
+            prompt_method:req.params.method
+        });
+        coloredLog("response saved -"+responseName);
+        return {payload,
+            businessOBJ,
+            promptOBJ,
+            chatContent,
+            responseName
+        };
+       
+    }
+
+    async function getGoogleDocContent(docUrl) {
+        try {
+            const auth = new google.auth.GoogleAuth({
+                scopes: ['https://www.googleapis.com/auth/documents.readonly']
+            });
+            //get google docs apikey from settings
+            const GOOGLE_API_KEY = JOE.Utils.Settings('GOOGLE_DOCS_API_KEY');
+            const docs = google.docs({ version: 'v1', auth:google_auth });
+            const docId = extractDocIdFromUrl(docUrl);
+            const doc = await docs.documents.get({ documentId: docId });
+
+            let content = doc.data.body.content.map(element => {
+                if (element.paragraph && element.paragraph.elements) {
+                    return element.paragraph.elements.map(
+                        e => e.textRun ? e.textRun.content.replace(/Euron Nicholson/g, '[EN]').replace(/\d{2}:\d{2}:\d{2}\.\d{3} --> \d{2}:\d{2}:\d{2}\.\d{3}/g, '-ts-')
+                        : ''
+                    ).join('');
+                }
+                return '';
+            }).join('\n');
+
+            // Remove timestamps and line numbers
+            //content = content.replace(/^\d+\n\d{2}:\d{2}:\d{2}\.\d{3} --> \d{2}:\d{2}:\d{2}\.\d{3}\n/gm, '');
+
+            return content;
+        } catch (error) {
+            console.error('Error fetching Google Doc content:', error);
+            return {error};
+        }
+    }
+    function countTokens(text, model = 'gpt-4o') {
+        const enc = encoding_for_model(model);
+        const tokens = enc.encode(text);
+        return tokens.length;
+    }
+    function extractDocIdFromUrl(url) {
+        const match = url.match(/\/d\/([a-zA-Z0-9-_]+)/);
+        return match ? match[1] : null;
+    }
+
+    async function saveAIResponse(data) {
+        try {
+            const aiResponse = {
+                name: data.name,
+                itemtype: 'ai_response',
+                business: data.business,
+                ai_prompt: data.ai_prompt,
+                response: data.response,
+                payload: data.payload,
+                prompt_method:data.prompt_method,
+                created: (new Date).toISOString(),
+                _id:cuid()
+                // Add any other fields you want to save
+            };
+            await new Promise((resolve, reject) => {
+                JOE.Storage.save(aiResponse, 'ai_response', function(err, result) {
+                    if (err) {
+                        coloredLog('Error saving AI response: ' + err);
+                        reject(err);
+                    } else {
+                        coloredLog('AI response saved successfully');
+                        resolve(result);
+                    }
+                });
+            });
+        } catch (error) {
+            coloredLog('Error in saveAIResponse: ' + error);
+        }
+    }
+
+    // Autofill feature (Responses API; supports assistant_id or model)
+    this.autofill = async function (data, req, res) {
+        const startedAt = Date.now();
+        try {
+            const body = data || {};
+            const objectId = body.object_id || body._id;
+            const object = body.object || $J.get(objectId);
+            const schemaName = body.schema || (object && object.itemtype) || body.itemtype;
+            const { full: schemaFull, summary: schemaSummary } = getSchemaDef(schemaName);
+            const rawFields = body.fields || body.field;
+            const fields = Array.isArray(rawFields) ? rawFields : (rawFields ? [rawFields] : []);
+            const userPrompt = body.prompt || '';
+            const assistantId = body.assistant_id || null;
+
+            if (!object) {
+                return { success: false, error: 'Object not found', code: 'OBJECT_NOT_FOUND' };
+            }
+            if (!schemaName) {
+                return { success: false, error: 'Schema name not determined', code: 'SCHEMA_REQUIRED' };
+            }
+            if (!fields.length) {
+                return { success: false, error: 'No fields specified', code: 'FIELDS_REQUIRED' };
+            }
+
+            const flattened = JOE.Utils.flattenObject(object._id);
+            const systemText = [
+                'You are JOE (Json Object Editor) assistant.',
+                'Task: Populate only the requested fields according to the provided schema context and JOE conventions.',
+                '- Respect field types (text, number, arrays, enums, references).',
+                '- Do NOT invent IDs for reference fields; only return human text for text-like fields.',
+                '- If a field is an enum, choose the closest valid enum. If unsure, omit it from patch.',
+                '- If a field is an array, return an array of values.',
+                '- Never modify unrelated fields.',
+                '- Output MUST be strict JSON with a top-level key "patch" containing only populated fields.',
+                '- If you lack sufficient information, return an empty patch.'
+            ].join('\\n');
+
+            const schemaForContext = schemaSummary || schemaFull || {};
+            const userInput = JSON.stringify({
+                action: 'autofill_fields',
+                target_schema: schemaName,
+                requested_fields: fields,
+                user_prompt: userPrompt,
+                object_context: flattened,
+                schema_context: schemaForContext
+            }, null, '  ');
+
+            const openai = newClient();
+            const model = body.model || 'gpt-4o-mini';
+
+            const requestBase = {
+                response_format: {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'joe_autofill_patch',
+                        strict: true,
+                        schema: {
+                            type: 'object',
+                            additionalProperties: false,
+                            required: ['patch'],
+                            properties: {
+                                patch: { type: 'object', additionalProperties: true }
+                            }
+                        }
+                    }
+                },
+                temperature: 0.2,
+                instructions: systemText,
+                input: userInput
+            };
+
+            let response;
+            if (assistantId) {
+                response = await openai.responses.create({ assistant_id: assistantId, ...requestBase });
+            } else {
+                response = await openai.responses.create({ model, ...requestBase });
+            }
+
+            let textOut = '';
+            try { textOut = response.output_text || ''; } catch (_e) {}
+            if (!textOut && response && Array.isArray(response.output)) {
+                for (let i = 0; i < response.output.length; i++) {
+                    const item = response.output[i];
+                    if (item && item.type === 'message' && item.content && Array.isArray(item.content)) {
+                        const textPart = item.content.find(function (c) { return c.type === 'output_text' || c.type === 'text'; });
+                        if (textPart && (textPart.text || textPart.output_text)) {
+                            textOut = textPart.text || textPart.output_text;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            let patch = {};
+            try {
+                const parsed = JSON.parse(textOut || '{}');
+                patch = parsed.patch || {};
+            } catch (_e) {}
+
+            const filteredPatch = {};
+            fields.forEach(function (f) {
+                if (Object.prototype.hasOwnProperty.call(patch, f)) {
+                    filteredPatch[f] = patch[f];
+                }
+            });
+
+            // Optional save
+            let savedItem = null;
+            if (body.save_history || body.save_itemtype) {
+                const targetItemtype = body.save_itemtype || 'ai_response';
+                if (JOE.Schemas && JOE.Schemas.schema && JOE.Schemas.schema[targetItemtype]) {
+                    const saveObj = {
+                        itemtype: targetItemtype,
+                        name: `[${schemaName}] autofill → ${fields.join(', ')}`,
+                        object_id: object._id,
+                        target_schema: schemaName,
+                        fields,
+                        prompt: userPrompt,
+                        patch: filteredPatch,
+                        model,
+                        raw: { response }
+                    };
+                    await new Promise(function (resolve) {
+                        JOE.Storage.save(saveObj, targetItemtype, function (_err, saved) {
+                            savedItem = saved || null;
+                            resolve();
+                        });
+                    });
+                }
+            }
+
+            return {
+                success: true,
+                patch: filteredPatch,
+                model,
+                usage: response && response.usage,
+                saved: !!savedItem,
+                saved_item: savedItem,
+                elapsed_ms: Date.now() - startedAt
+            };
+        } catch (e) {
+            return { success: false, error: e && e.message || 'Unknown error' };
+        }
+    };
+
+    this.getResponse = function(data, req, res) {
+        try {
+            var prompt = data.prompt;
+            if (!prompt) {
+                return { error: 'No prompt provided' };
+            }
+
+            // Simulate a response from ChatGPT
+            var response = `ChatGPT response to: ${prompt}`;
+            res.jsonp({ response: response });
+            return { use_callback: true };
+        } catch (e) {
+            return { errors: 'plugin error: ' + e, failedat: 'plugin' };
+        }
+    };
+
+    this.html = function(data, req, res) {
+        return JSON.stringify(self.default(data, req), '', '\t\r\n <br/>');
+    };
+/* NEW AI RESPONSE API*/
+
+this.executeJOEAiPrompt = async function(data, req, res) {
+    const referencedObjectIds = []; // Track all objects touched during helper function
+    try {
+        const promptId = data.ai_prompt;
+        const params = data;
+
+        if (!promptId) {
+            return { error: "Missing prompt_id." };
+        }
+
+        const prompt = await $J.get(promptId); // Use $J.get for consistency
+        if (!prompt) {
+            return { error: "Prompt not found." };
+        }
+
+        let instructions = prompt.instructions || "";
+        let finalInstructions=instructions;
+        let finalInput='';
+        // Pre-load all content_objects if content_items exist
+        const contentObjects = {};
+
+        if (prompt.content_items && Array.isArray(prompt.content_items)) {
+            for (const content of prompt.content_items) {
+                if (params[content.reference]) {
+                    const obj = $J.get(params[content.reference]);
+                    if (obj) {
+                        contentObjects[content.itemtype] = obj;
+
+                        // Pre-track referenced object
+                        if (obj._id && !referencedObjectIds.includes(obj._id)) {
+                            referencedObjectIds.push(obj._id);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Execute any helper functions if present
+        if (prompt.functions) {
+            const modFunc = JOE.Utils.requireFromString(prompt.functions, prompt._id);
+            const helperResult = await modFunc({ 
+                instructions, 
+                params, 
+                ai_prompt: prompt,
+                content_objects: contentObjects,
+                trackObject: (obj) => {
+                    if (obj?._id && !referencedObjectIds.includes(obj._id)) {
+                        referencedObjectIds.push(obj._id);
+                    }
+                }
+            });
+
+            if (typeof helperResult === 'object' && helperResult.error) {
+                return { error: helperResult.error };
+            }
+            
+            // Assume the result is { instructions, input }
+            finalInstructions = helperResult.instructions || instructions;
+            finalInput = helperResult.input;
+        }
+
+        const openai = newClient(); // however your OpenAI client is created
+
+        const payload = {
+            model: prompt.ai_model || "gpt-4o",
+            instructions: finalInstructions||instructions, // string only
+            input:finalInput||'',
+            tools: prompt.tools || [{ "type": "web_search" }],
+            tool_choice: prompt.tool_choice || "auto",
+            temperature: prompt.temperature ? parseFloat(prompt.temperature) : 0.7,
+            //return_token_usage: true
+            //max_tokens: prompt.max_tokens ?? 1200
+          };
+          
+          const response = await openai.responses.create(payload);
+
+
+        // const payload = createResponsePayload(prompt, params, instructions, data.user_prompt);
+
+        // const response = await openai.chat.completions.create(payload);
+
+        const saved = await saveAiResponseRefactor({
+            prompt,
+            ai_response_content: response.output_text || "",
+            user_prompt: payload.input,
+            params,
+            referenced_object_ids: referencedObjectIds,
+            response_id:response.id,
+            usage: response.usage || {}
+        });
+
+        return { success: true, ai_response_id: saved._id,response:response.output_text || "",usage:response.usage };
+    } catch (e) {
+        console.error('❌ executeJOEAiPrompt error:', e);
+        return { error: "Failed to execute AI prompt.",message: e.message };
+    }
+};
+
+    function createResponsePayload(prompt, params, instructions, user_prompt) {
+        return {
+            model: prompt.model || "gpt-4o",
+            messages: [
+                { role: "system", content: instructions },
+                { role: "user", content: user_prompt || "" }
+            ],
+            tools: prompt.tools || undefined,
+            tool_choice: prompt.tool_choice || "auto",
+            temperature: prompt.temperature ?? 0.7,
+            max_tokens: prompt.max_tokens ?? 1200
+        };
+    }
+    async function saveAiResponseRefactor({ prompt, ai_response_content, user_prompt, params, referenced_object_ids,response_id,usage}) {
+        var response_keys = [];
+        try {
+            response_keys = Object.keys(JSON.parse(ai_response_content));
+        }catch (e) {
+            console.error('❌ Error parsing AI response content for keys:', e);
+        }
+        const aiResponse = {
+            name: `${prompt.name}`,
+            itemtype: 'ai_response',
+            ai_prompt: prompt._id,
+            prompt_name: prompt.name,
+            prompt_method:prompt.prompt_method,
+            response: ai_response_content,
+            response_keys: response_keys,
+            response_id:response_id||'',
+            user_prompt: user_prompt,
+            params_used: params,
+            usage: usage || {},
+            tags: prompt.tags || [],
+            model_used: prompt.ai_model || "gpt-4o",
+            referenced_objects: referenced_object_ids, // new flexible array of referenced object ids
+            created: (new Date).toISOString(),
+            _id: cuid()
+        };
+    
+        await new Promise((resolve, reject) => {
+            JOE.Storage.save(aiResponse, 'ai_response', function(err, result) {
+                if (err) {
+                    console.error('❌ Error saving AI response:', err);
+                    reject(err);
+                } else {
+                    console.log('✅ AI response saved successfully');
+                    resolve(result);
+                }
+            });
+        });
+    
+        return aiResponse;
+    }
+
+    // ---------- Widget chat endpoints (Responses API + optional assistants) ----------
+    function normalizeMessages(messages) {
+        if (!Array.isArray(messages)) { return []; }
+        return messages.map(function (m) {
+            return {
+                role: m.role || 'assistant',
+                content: m.content || '',
+                created_at: m.created_at || m.created || new Date().toISOString()
+            };
+        });
+    }
+
+    this.widgetStart = async function (data, req, res) {
+        try {
+            var body = data || {};
+            var model = body.model || "gpt-4.1-mini";
+            var assistant = body.ai_assistant_id ? $J.get(body.ai_assistant_id) : null;
+            var system = body.system || (assistant && assistant.instructions) || "";
+
+            var convo = {
+                _id: (typeof cuid === 'function') ? cuid() : undefined,
+                itemtype: "ai_widget_conversation",
+                model: assistant && assistant.ai_model || model,
+                assistant: assistant && assistant._id,
+                assistant_id: assistant && assistant.assistant_id,
+                system: system,
+                messages: [],
+                source: body.source || "widget",
+                created: new Date().toISOString(),
+                joeUpdated: new Date().toISOString()
+            };
+
+            const saved = await new Promise(function (resolve, reject) {
+                JOE.Storage.save(convo, "ai_widget_conversation", function (err, result) {
+                    if (err) return reject(err);
+                    resolve(result);
+                });
+            });
+
+            return {
+                success: true,
+                conversation_id: saved._id,
+                model: saved.model,
+                assistant_id: saved.assistant_id || null
+            };
+        } catch (e) {
+            console.error("[chatgpt] widgetStart error:", e);
+            return { success: false, error: e && e.message || "Unknown error" };
+        }
+    };
+
+    this.widgetHistory = async function (data, req, res) {
+        try {
+            var conversation_id = data.conversation_id || data._id;
+            if (!conversation_id) {
+                return { success: false, error: "Missing conversation_id" };
+            }
+            const convo = await new Promise(function (resolve, reject) {
+                JOE.Storage.load("ai_widget_conversation", { _id: conversation_id }, function (err, results) {
+                    if (err) return reject(err);
+                    resolve(results && results[0]);
+                });
+            });
+            if (!convo) {
+                return { success: false, error: "Conversation not found" };
+            }
+
+            convo.messages = normalizeMessages(convo.messages);
+            return {
+                success: true,
+                conversation_id: convo._id,
+                model: convo.model,
+                assistant_id: convo.assistant_id || null,
+                messages: convo.messages
+            };
+        } catch (e) {
+            console.error("[chatgpt] widgetHistory error:", e);
+            return { success: false, error: e && e.message || "Unknown error" };
+        }
+    };
+
+    this.widgetMessage = async function (data, req, res) {
+        try {
+            var body = data || {};
+            var conversation_id = body.conversation_id || body._id;
+            var content = body.content;
+            var role = body.role || "user";
+
+            if (!conversation_id || !content) {
+                return { success: false, error: "Missing conversation_id or content" };
+            }
+
+            const convo = await new Promise(function (resolve, reject) {
+                JOE.Storage.load("ai_widget_conversation", { _id: conversation_id }, function (err, results) {
+                    if (err) return reject(err);
+                    resolve(results && results[0]);
+                });
+            });
+            if (!convo) {
+                return { success: false, error: "Conversation not found" };
+            }
+
+            convo.messages = normalizeMessages(convo.messages);
+            const nowIso = new Date().toISOString();
+
+            // Append user message
+            const userMsg = { role: role, content: content, created_at: nowIso };
+            convo.messages.push(userMsg);
+
+            const openai = newClient();
+            const assistantId = body.assistant_id || convo.assistant_id || null;
+            const model = convo.model || body.model || "gpt-4.1-mini";
+
+            const systemText = convo.system || "";
+            const messagesForModel = convo.messages.map(function (m) {
+                return { role: m.role, content: m.content };
+            });
+
+            let response;
+            if (assistantId) {
+                response = await openai.responses.create({
+                    assistant_id: assistantId,
+                    input: messagesForModel
+                });
+            } else {
+                response = await openai.responses.create({
+                    model: model,
+                    instructions: systemText,
+                    input: messagesForModel
+                });
+            }
+
+            const assistantText = response.output_text || "";
+            const assistantMsg = {
+                role: "assistant",
+                content: assistantText,
+                created_at: new Date().toISOString()
+            };
+            convo.messages.push(assistantMsg);
+            convo.last_message_at = assistantMsg.created_at;
+            convo.joeUpdated = assistantMsg.created_at;
+
+            await new Promise(function (resolve, reject) {
+                JOE.Storage.save(convo, "ai_widget_conversation", function (err, saved) {
+                    if (err) return reject(err);
+                    resolve(saved);
+                });
+            });
+
+            return {
+                success: true,
+                conversation_id: convo._id,
+                model: model,
+                assistant_id: assistantId,
+                messages: convo.messages,
+                last_message: assistantMsg,
+                usage: response.usage || {}
+            };
+        } catch (e) {
+            console.error("[chatgpt] widgetMessage error:", e);
+            return { success: false, error: e && e.message || "Unknown error" };
+        }
+    };
+
+    this.async={
+        executeJOEAiPrompt:this.executeJOEAiPrompt,
+        testPrompt:this.testPrompt,
+        sendInitialConsultTranscript:this.sendInitialConsultTranscript,
+    }
+    this.protected = [,'testPrompt'];
+    return self;
+}
+
+module.exports = new ChatGPT();