json-object-editor 0.10.657 → 0.10.660

package/server/plugins/chatgpt.js

@@ -1474,9 +1474,15 @@ this.executeJOEAiPrompt = async function(data, req, res) {
                 system: system,
                 messages: [],
                 source: body.source || "widget",
+                // Optional scope for object-scoped widget chats
+                scope_itemtype: body.scope_itemtype || null,
+                scope_id: body.scope_id || null,
                 created: new Date().toISOString(),
                 joeUpdated: new Date().toISOString()
             };
+            if (body.name && !convo.name) {
+                convo.name = String(body.name);
+            }
 
             const saved = await new Promise(function (resolve, reject) {
                 // Widget conversations are lightweight and do not need full history diffs.
@@ -1598,7 +1604,76 @@ this.executeJOEAiPrompt = async function(data, req, res) {
                 return { success: false, error: "Conversation not found" };
             }
 
+            // Best-effort: if this is an object-scoped conversation and we have
+            // not yet attached any files, walk the scoped object for uploader
+            // style files that have OpenAI ids and cache them on the convo.
+            try{
+                if ((!convo.attached_openai_file_ids || !convo.attached_openai_file_ids.length) &&
+                    convo.scope_itemtype && convo.scope_id) {
+                    var scopedObj = null;
+                    try{
+                        scopedObj = $J.get(convo.scope_id, convo.scope_itemtype) || $J.get(convo.scope_id);
+                    }catch(_e){}
+                    if (scopedObj && typeof scopedObj === 'object') {
+                        var ids = [];
+                        var meta = [];
+                        Object.keys(scopedObj).forEach(function(field){
+                            var val = scopedObj[field];
+                            if (!Array.isArray(val)) { return; }
+                            val.forEach(function(f){
+                                if (f && f.openai_file_id) {
+                                    ids.push(f.openai_file_id);
+                                    meta.push({
+                                        itemtype: scopedObj.itemtype || convo.scope_itemtype,
+                                        field: field,
+                                        name: f.filename || '',
+                                        role: f.file_role || null,
+                                        openai_file_id: f.openai_file_id
+                                    });
+                                }
+                            });
+                        });
+                        if (ids.length) {
+                            convo.attached_openai_file_ids = ids;
+                            convo.attached_files_meta = meta;
+                        }
+                    }
+                }
+            }catch(_e){ /* non-fatal */ }
+
             convo.messages = normalizeMessages(convo.messages);
+
+            // On the very first turn of an object-scoped widget conversation,
+            // pre-load a slimmed understandObject snapshot so the assistant
+            // immediately knows which record "this client/task/..." refers to
+            // without having to remember to call MCP. We keep this snapshot
+            // concise via slimUnderstandObjectResult and only inject it once.
+            try{
+                var isObjectChat = (convo.source === 'object_chat') && convo.scope_id;
+                var hasMessages = Array.isArray(convo.messages) && convo.messages.length > 0;
+                if (isObjectChat && !hasMessages){
+                    const uo = await callMCPTool('understandObject', {
+                        _id: convo.scope_id,
+                        itemtype: convo.scope_itemtype || undefined,
+                        depth: 1,
+                        slim: true
+                    }, { req });
+                    const slimmed = slimUnderstandObjectResult(uo);
+                    if (slimmed) {
+                        convo.messages = convo.messages || [];
+                        convo.messages.push({
+                            role: 'system',
+                            content: JSON.stringify({
+                                tool: 'understandObject',
+                                scope_object: slimmed
+                            })
+                        });
+                    }
+                }
+            }catch(_e){
+                console.warn('[chatgpt] widgetMessage understandObject preload failed', _e && _e.message || _e);
+            }
+
             const nowIso = new Date().toISOString();
 
             // Append user message
@@ -1645,22 +1720,79 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             const model = (assistantObj && assistantObj.ai_model) || convo.model || body.model || "gpt-5.1";
 
             // Prefer explicit system text on the conversation, then assistant instructions.
-            const systemText = (convo.system && String(convo.system)) ||
+            const baseSystemText = (convo.system && String(convo.system)) ||
                 (assistantObj && assistantObj.instructions) ||
                 "";
+
+            // When this conversation was launched from an object ("Start Chat"
+            // on a record), include a small scope hint so the assistant knows
+            // which object id/itemtype to use with MCP tools like
+            // understandObject/search. We keep this concise to avoid
+            // unnecessary tokens but still make the scope unambiguous.
+            let systemText = baseSystemText;
+            try{
+                if (convo.source === 'object_chat' && convo.scope_id) {
+                    const scopeLine = '\n\n---\nJOE scope_object:\n'
+                        + '- itemtype: ' + String(convo.scope_itemtype || 'unknown') + '\n'
+                        + '- _id: ' + String(convo.scope_id) + '\n'
+                        + 'When you need this object\'s details, call the MCP tool "understandObject" '
+                        + 'with these identifiers, or search for related records using the MCP search tools.\n';
+                    systemText = (baseSystemText || '') + scopeLine;
+                }
+            }catch(_e){ /* non-fatal */ }
+
+            // Build the messages array for the model. We deliberately separate
+            // the stored `convo.messages` from the model-facing payload so we
+            // can annotate the latest user turn with uploaded_files metadata
+            // without altering the persisted history.
             const messagesForModel = convo.messages.map(function (m) {
                 return { role: m.role, content: m.content };
             });
+            // If we have attached file metadata, wrap the latest user turn in a
+            // small JSON envelope so the model can see which files exist and how
+            // they are labeled (role, name, origin field) while still receiving
+            // the raw user input as `input`.
+            try{
+                if (convo.attached_files_meta && convo.attached_files_meta.length && messagesForModel.length) {
+                    var lastMsg = messagesForModel[messagesForModel.length - 1];
+                    if (lastMsg && lastMsg.role === role && typeof lastMsg.content === 'string') {
+                        lastMsg.content = JSON.stringify({
+                            uploaded_files: convo.attached_files_meta,
+                            input: lastMsg.content
+                        }, null, 2);
+                    }
+                }
+            }catch(_e){ /* non-fatal */ }
+
+            // Collect OpenAI file ids from scoped object attachments and any
+            // assistant-level files so they are available to the model via the
+            // shared attachFilesToResponsesPayload helper inside runWithTools.
+            var openaiFileIds = [];
+            if (Array.isArray(convo.attached_openai_file_ids) && convo.attached_openai_file_ids.length){
+                openaiFileIds = openaiFileIds.concat(convo.attached_openai_file_ids);
+            }
+            try{
+                if (assistantObj && Array.isArray(assistantObj.assistant_files)) {
+                    assistantObj.assistant_files.forEach(function(f){
+                        if (f && f.openai_file_id) {
+                            openaiFileIds.push(f.openai_file_id);
+                        }
+                    });
+                }
+            }catch(_e){}
 
             // Use runWithTools so that, when an assistant has tools configured,
-            // we let the model call those tools via MCP before generating a
-            // final response.
+            // we let the model call those tools via MCP / function tools before
+            // generating a final response. Attach any discovered OpenAI files
+            // so the model can read from them as needed.
             const runResult = await runWithTools({
                 openai: openai,
                 model: model,
                 systemText: systemText,
                 messages: messagesForModel,
                 assistant: assistantObj,
+                attachments_mode: (body.attachments_mode || 'direct'),
+                openai_file_ids: openaiFileIds.length ? openaiFileIds : null,
                 req: req
             });
 

package/server/schemas/ai_assistant.js

@@ -3,7 +3,7 @@
 
 var schema = {
     title: "Ai Assistant | ${name}",
-    display: "Ai Assist",
+    display: "Ai Assistant",
     info: "An AI Assistant configuration linked to OpenAI, managed within Joe.",
     // Curated summary for agents and tools
     summary:{
@@ -329,6 +329,20 @@ var schema = {
             display: "File IDs (auto populated on sync)",
             comment: "Auto-managed list of OpenAI file_ids attached to this Assistant."
           },
+          {
+            name:"assistant_files",
+            type:"uploader",
+            allowmultiple:true,
+            height:"220px",
+            display:"Assistant Files (uploaded)",
+            comment:"Drag files here to upload. Files will be mirrored to OpenAI (when configured) and attached whenever this assistant is used.",
+            onConfirm:_joe.SERVER.Plugins.awsConnect,
+            file_roles:[
+              { value:"reference",   label:"Reference" },
+              { value:"instructions",label:"Instructions" },
+              { value:"example",     label:"Example", default:true }
+            ]
+          },
         { section_end: "files" },
         {section_start:'categorization',collapsed:true},
         'datasets',

package/server/schemas/ai_widget_conversation.js

@@ -31,6 +31,12 @@ var schema = {
       { name:'messages', type:'objectList' },
       { name:'last_message_at', type:'string', format:'date-time' },
       { name:'source', type:'string' },
+      // Optional scope for object-scoped chats (Start Chat on an object)
+      { name:'scope_itemtype', type:'string' },
+      { name:'scope_id', type:'string' },
+      // Optional attached OpenAI Files (ids + meta) for this conversation
+      { name:'attached_openai_file_ids', type:'string', isArray:true },
+      { name:'attached_files_meta', type:'objectList' },
       { name:'user', type:'string', isReference:true, targetSchema:'user' },
       { name:'user_name', type:'string' },
       { name:'user_color', type:'string' },
@@ -176,6 +182,31 @@ var schema = {
 
       { section_start: "meta", collapsed: true },
         "source",
+        {
+          name:"scope_itemtype",
+          type:"text",
+          display:"Scope Itemtype",
+          comment:"When set, this conversation is scoped to a specific object type (e.g., client, task)."
+        },
+        {
+          name:"scope_id",
+          type:"text",
+          display:"Scope ID",
+          comment:"When set, this conversation is scoped to a specific object _id."
+        },
+        {
+          name:"attached_openai_file_ids",
+          type:"text",
+          display:"Attached OpenAI File IDs",
+          locked:true
+        },
+        {
+          name:"attached_files_meta",
+          type:"code",
+          display:"Attached Files Meta (JSON)",
+          height:"160px",
+          comment:"Read-only meta for files attached to this conversation (itemtype, field, name, role, openai_file_id)."
+        },
         "tags",
       { section_end: "meta" },