json-object-editor 0.10.642 → 0.10.653

package/server/plugins/chatgpt.js

@@ -432,7 +432,40 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
                 model: 'gpt-4o',
             });
             coloredLog(chatCompletion);
-            return {payload,chatCompletion,content:chatCompletion.choices[0].message.content};
+            const text = chatCompletion.choices && chatCompletion.choices[0] && chatCompletion.choices[0].message && chatCompletion.choices[0].message.content || '';
+            // Optionally persist as ai_response with parsed JSON when applicable
+            const parsed = (function(){
+                try {
+                    const jt = extractJsonText(text);
+                    return jt ? JSON.parse(jt) : null;
+                } catch(_e){ return null; }
+            })();
+            try {
+                var creator_type = null;
+                var creator_id = null;
+                try{
+                    var u = req && req.User;
+                    if (u && u._id){
+                        creator_type = 'user';
+                        creator_id = u._id;
+                    }
+                }catch(_e){}
+                const aiResponse = {
+                    itemtype: 'ai_response',
+                    name: 'Test Prompt → ChatGPT',
+                    response_type: 'testPrompt',
+                    response: text,
+                    response_json: parsed,
+                    response_id: chatCompletion.id || '',
+                    user_prompt: payload && payload.data && payload.data.prompt || 'Tell me a story about JOE: the json object editor in under 256 chars.',
+                    model_used: 'gpt-4o',
+                    created: (new Date()).toISOString(),
+                    creator_type: creator_type,
+                    creator_id: creator_id
+                };
+                JOE.Storage.save(aiResponse, 'ai_response', function(){}, { history: false, user: (req && req.User) || { name:'system' } });
+            } catch(_e){ /* best-effort only */ }
+            return {payload,chatCompletion,content:text};
         } catch (error) {
             if (error.status === 429) {
                 return { errors: 'You exceeded your current quota, please check your plan and billing details.' };
@@ -498,7 +531,7 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
             response: chatContent,
             payload,
             prompt_method:req.params.method
-        });
+        }, req && req.User);
         coloredLog("response saved -"+responseName);
         return {payload,
             businessOBJ,
@@ -549,8 +582,16 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
         return match ? match[1] : null;
     }
 
-    async function saveAIResponse(data) {
+    async function saveAIResponse(data, user) {
         try {
+            var creator_type = null;
+            var creator_id = null;
+            try{
+                if (user && user._id){
+                    creator_type = 'user';
+                    creator_id = user._id;
+                }
+            }catch(_e){}
             const aiResponse = {
                 name: data.name,
                 itemtype: 'ai_response',
@@ -560,7 +601,9 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
                 payload: data.payload,
                 prompt_method:data.prompt_method,
                 created: (new Date).toISOString(),
-                _id:cuid()
+                _id:cuid(),
+                creator_type: creator_type,
+                creator_id: creator_id
                 // Add any other fields you want to save
             };
             await new Promise((resolve, reject) => {
@@ -880,7 +923,9 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             params,
             referenced_object_ids: referencedObjectIds,
             response_id:response.id,
-            usage: response.usage || {}
+            usage: response.usage || {},
+            user: req && req.User,
+            ai_assistant_id: data.ai_assistant_id
         });
 
         return { success: true, ai_response_id: saved._id,response:response.output_text || "",usage:response.usage };
@@ -903,13 +948,34 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             max_tokens: prompt.max_tokens ?? 1200
         };
     }
-    async function saveAiResponseRefactor({ prompt, ai_response_content, user_prompt, params, referenced_object_ids,response_id,usage}) {
+    async function saveAiResponseRefactor({ prompt, ai_response_content, user_prompt, params, referenced_object_ids,response_id,usage,user,ai_assistant_id}) {
         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);
         }
+        // Best-effort parse into JSON for downstream agents (Thought pipeline, etc.)
+        let parsedResponse = null;
+        try {
+            const jt = extractJsonText(ai_response_content);
+            if (jt) {
+                parsedResponse = JSON.parse(jt);
+            }
+        } catch(_e) {
+            parsedResponse = null;
+        }
+        var creator_type = null;
+        var creator_id = null;
+        try{
+            if (ai_assistant_id){
+                creator_type = 'ai_assistant';
+                creator_id = ai_assistant_id;
+            } else if (user && user._id){
+                creator_type = 'user';
+                creator_id = user._id;
+            }
+        }catch(_e){}
         const aiResponse = {
             name: `${prompt.name}`,
             itemtype: 'ai_response',
@@ -917,6 +983,7 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             prompt_name: prompt.name,
             prompt_method:prompt.prompt_method,
             response: ai_response_content,
+            response_json: parsedResponse,
             response_keys: response_keys,
             response_id:response_id||'',
             user_prompt: user_prompt,
@@ -926,7 +993,9 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             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()
+            _id: cuid(),
+            creator_type: creator_type,
+            creator_id: creator_id
         };
     
         await new Promise((resolve, reject) => {

package/server/schemas/ai_pipeline.js

@@ -0,0 +1,90 @@
+var schema = {
+    title: "AI Pipeline | ${name}",
+    display: "AI Pipeline",
+    info: "Configurable AI context pipelines composed of ordered steps, used to compile context for agents like the Thought Engine.",
+    summary: {
+        description: "Declarative definition of AI context pipelines: an ordered list of steps (schema summaries, thoughts, objects, etc.) that feed agents.",
+        purpose: "Use ai_pipeline to configure what context is compiled for a given agent run (e.g., which schemas, thoughts, and objects are included) without changing code.",
+        labelField: "name",
+        defaultSort: { field: "created", dir: "desc" },
+        searchableFields: ["name", "pipeline_id", "info", "_id"],
+        allowedSorts: ["created", "joeUpdated", "name"],
+        relationships: {
+            outbound: [
+                // Future: agents that reference this pipeline_id
+            ],
+            inbound: { graphRef: "server/relationships.graph.json" }
+        },
+        joeManagedFields: ["created", "joeUpdated"],
+        fields: [
+            { name: "_id", type: "string", required: true },
+            { name: "itemtype", type: "string", required: true, const: "ai_pipeline" },
+            { name: "name", type: "string", required: true },
+            { name: "pipeline_id", type: "string", required: true },
+            { name: "info", type: "string" },
+            // Steps are minimal, but expressive enough to mirror current PIPELINES config
+            { name: "steps", type: "objectList" },
+            { name: "joeUpdated", type: "string", format: "date-time" },
+            { name: "created", type: "string", format: "date-time" }
+        ]
+    },
+    listView: {
+        title: function (p) {
+            return `
+        <joe-subtext>${_joe.Utils.prettyPrintDTS(p.created)}</joe-subtext>
+        <joe-title>${p.name}</joe-title>
+        <joe-subtitle>${p.pipeline_id || ""}</joe-subtitle>
+        `;
+        },
+        listWindowTitle: "AI Pipelines"
+    },
+    sorter: ["!created", "name"],
+    fields: [
+        "name",
+        { name: "pipeline_id", width: "50%", comment: "Logical id used by agents and ThoughtPipeline (e.g., thought_default, protocol_planning)." },
+        "info",
+
+        { section_start: "steps", display: "Pipeline Steps", collapsed: false },
+        {
+            name: "steps",
+            type: "objectList",
+            display: "Steps",
+            comment: "Ordered steps that define how context is compiled.",
+            properties: [
+                { name: "id", width: "20%", comment: "Stable step id (e.g., schema_summaries, accepted_thoughts)." },
+                {
+                    name: "step_type",
+                    type: "select",
+                    values: ["schema_summaries", "thoughts", "objects", "scope_object", "text", "tools"],
+                    width: "15%",
+                    comment: "Determines how this step is executed."
+                },
+                {
+                    name: "render_mode",
+                    type: "select",
+                    values: ["json", "compact_json", "bullets", "text"],
+                    width: "15%",
+                    comment: "How this step is rendered into the agent prompt."
+                },
+                { name: "required", type: "boolean", width: "10%", comment: "If true, pipeline fails when this step cannot be resolved." },
+                {
+                    name: "selector",
+                    type: "code",
+                    language: "json",
+                    width: "40%",
+                    comment: "Free-form selector JSON (e.g., { \"names\": [\"thought\",\"ai_prompt\" ] } or { \"query\": {\"itemtype\":\"thought\"}, \"sortBy\":\"joeUpdated\" } )."
+                }
+            ]
+        },
+        { section_end: "steps" },
+
+        { section_start: "system", collapsed: true },
+        "_id",
+        "created",
+        "itemtype",
+        { section_end: "system" }
+    ],
+    idprop: "_id"
+};
+
+module.exports = schema;

package/server/schemas/ai_response.js

@@ -1,5 +1,6 @@
 var schema = {
     title : 'Ai Response | ${name}',
+    display:'AI Response',
     info:"An ai response from openai etc",
     summary:{
         description:'Stored AI response objects generated from ai_prompt and the chatgpt plugin.',
@@ -23,14 +24,18 @@ var schema = {
             { name:'name', type:'string', required:true },
             { name:'ai_prompt', type:'string', isReference:true, targetSchema:'ai_prompt' },
             { name:'referenced_objects', type:'string', isArray:true },
+            { name:'generated_thoughts', type:'string', isArray:true, isReference:true, targetSchema:'thought' },
             { name:'user_prompt', type:'string' },
             { name:'prompt_method', type:'string' },
             { name:'model_used', type:'string' },
             { name:'response_type', type:'string' },
             { name:'response', type:'string' },
+            { name:'response_json', type:'object' },
             { name:'response_keys', type:'string', isArray:true },
             { name:'response_id', type:'string' },
             { name:'usage', type:'object' },
+            // { name:'creator_type', type:'string', enumValues:['user','ai_assistant'] },
+            // { name:'creator_id', type:'string' },
             { name:'tags', type:'string', isArray:true, isReference:true, targetSchema:'tag' },
             { name:'joeUpdated', type:'string', format:'date-time' },
             { name:'created', type:'string', format:'date-time' }
@@ -60,18 +65,129 @@ var schema = {
         },
         listWindowTitle: 'Ai Responses'
     },
-    subsets: function(){
-        return _joe.Filter.Options.tags({group:true,collapsed:false}).concat(_joe.getDataset('ai_prompt').map(prompt => {
-            var color = prompt.status && $J.get(prompt.status,'status').color;
-          return {
-            name: prompt.name,
-            id: prompt._id,
-            filter: { ai_prompt: prompt._id },
-            stripecolor: color || null // optional
-          };
-        }))
-      },
+    subsets: function(a,b,c){
+        // Base subsets: tag-based and by ai_prompt
+        var subsets = _joe.Filter.Options.tags({group:true,collapsed:false}).concat(
+            _joe.getDataset('ai_prompt').map(function(prompt){
+                var color = prompt.status && $J.get(prompt.status,'status').color;
+                return {
+                    name: prompt.name,
+                    id: prompt._id,
+                    filter: { ai_prompt: prompt._id },
+                    stripecolor: color || null // optional
+                };
+            })
+        );
 
+        // Additional subset: "Generated Thoughts" – detect from raw JSON
+        // We look inside response_json for proposed_thoughts / thoughts arrays.
+        try{
+            var ds = _joe.getDataset('ai_response') || [];
+            var ids = [];
+            ds.map(function(r){
+                var j = r && r.response_json;
+                if (!j) { return; }
+                if (Array.isArray(j.proposed_thoughts) && j.proposed_thoughts.length) {
+                    ids.push(r._id);
+                    return;
+                }
+                if (Array.isArray(j.thoughts) && j.thoughts.length) {
+                    ids.push(r._id);
+                }
+            });
+            if (ids.length) {
+                subsets.push({
+                    name: 'Generated Thoughts',
+                    id: 'generated_thoughts',
+                    filter: { _id: { $in: ids } },
+                    stripecolor: _joe.Colors.ai
+                });
+            }
+        }catch(_e){ /* best-effort only */ }
+        // subsets.push(
+        //     {
+        //         name: 'True',
+        //         id: 'isTrue',
+        //         filter: function(air,index, arra){
+        //             return air.response_json && air.response_json.proposed_thoughts && air.response_json.proposed_thoughts.length > 0;
+        //         },
+        //         stripecolor: 'gold'
+        //     }
+        // );
+        return subsets;
+      },
+      stripeColor:function(air){
+        if(air.response_json && air.response_json.proposed_thoughts){
+            return {color:_joe.Colors.ai,title:'Proposed '+air.response_json.proposed_thoughts.length+' Thoughts'};
+        }
+        return null;
+      },
+    filters:function(){
+        var filters = [];
+        // Tag filters
+        filters = filters.concat(
+            _joe.Filter.Options.tags({group:'tags',untagged:true,collapsed:true})
+        );
+        // creator_type simple value grouping
+        // try{
+        //     filters = filters.concat(
+        //         _joe.Filter.Options.getDatasetPropertyValues('ai_response','creator_type',{ group: 'creator_type', collapsed: true })
+        //     );
+        // }catch(_e){}
+        // // creator_id filters with human-readable names
+        // try{
+        //     var dataset = _joe.getDataset('ai_response') || [];
+        //     var byCreator = {};
+        //     dataset.map(function(r){
+        //         if(!r.creator_id){ return; }
+        //         var key = r.creator_type+':'+r.creator_id;
+        //         if(!byCreator[key]){
+        //             var name = r.creator_id;
+        //             if(r.creator_type === 'user' && _joe.Data.user){
+        //                 var u = _joe.Data.user.find(function(x){ return x && x._id === r.creator_id; });
+        //                 if(u){ name = u.fullname || u.name || u.email || u._id; }
+        //             }else if(r.creator_type === 'ai_assistant' && _joe.Data.ai_assistant){
+        //                 var a = _joe.Data.ai_assistant.find(function(x){ return x && x._id === r.creator_id; });
+        //                 if(a){ name = a.name || a._id; }
+        //             }
+        //             byCreator[key] = {
+        //                 name: name,
+        //                 filter: { creator_type: r.creator_type, creator_id: r.creator_id }
+        //             };
+        //         }
+        //     });
+        //     var keys = Object.keys(byCreator);
+        //     if(keys.length){
+        //         filters.push({ group_start:'creator', collapsed:true });
+        //         keys.sort(function(a,b){
+        //             var na = byCreator[a].name.toLowerCase();
+        //             var nb = byCreator[b].name.toLowerCase();
+        //             if(na>nb) return 1;
+        //             if(na<nb) return -1;
+        //             return 0;
+        //         }).map(function(k){
+        //             filters.push({
+        //                 name: byCreator[k].name,
+        //                 filter: byCreator[k].filter
+        //             });
+        //         });
+        //         filters.push({ group_end:'creator' });
+        //     }
+        // }catch(_e){}
+        return filters;
+    },
+    itemExpander:function(air){
+        if(air.response_json && air.response_json.proposed_thoughts){
+        //list proposed thoughts in html with header "Proposed Thoughts"
+        var html = `<joe-card><joe-title>Proposed Thoughts</joe-title>`;
+        air.response_json.proposed_thoughts.map(thought=>{
+            html += `<joe-subtitle>${thought.statement}</joe-subtitle><br/>`;
+        });
+        html += `</joe-card>`;
+        return html;
+        }
+        return _joe.schemas.thought.methods.listThoughts(air);
+    },
     sorter:['!created','name'],
     checkChanges:false,
     fields:[
@@ -81,6 +197,9 @@ var schema = {
         {name:'referenced_objects',type:'objectReference',width:'50%',values:function(air,orList){
             return $J.search({_id:{$in:air.referenced_objects}});
         },display:'Referenced Objects',locked:true},
+        {name:'generated_thoughts',type:'objectReference',width:'50%',values:function(air,orList){
+            return $J.search({source_ai_response:air._id,itemtype:'thought'});
+        },display:'Generated Thoughts',locked:true},
         {name:'user_prompt', display:'Sent User Prompt',comment:"The input sent by the user after all processing",locked:true,type:'rendering'},
         
         {name:'prompt_method',locked:true,width:'50%'},
@@ -94,17 +213,47 @@ var schema = {
  
         //{name:'params', type:'rendering', locked:true},
         {section_start:'response',collapsed:false},
-            {name:'response_type',type:'text',display:'Response Type',
-                placeholder:'(a code for the responsetype)',locked:true,width:'50%',condition:function(v){
+            {
+                name:'response_type',
+                type:'text',
+                display:'Response Type',
+                placeholder:'(a code for the responsetype)',
+                locked:true,
+                width:'50%',
+                condition:function(v){
                     return v.length > 0;
-                }},
-            
-            {name:'response', type:'rendering', locked:true,height:'500px'},
+                }
+            },
+            {name:'response', type:'rendering', locked:true, height:'500px'},
+            {
+                name:'response_json',
+                type:'content',
+                display:'Parsed Response (JSON)',
+                locked:true,
+                run:function(air){
+                    if (!air || !air.response_json) { return ''; }
+                    try{
+                        var json = JSON.stringify(air.response_json, null, 2);
+                        // basic HTML escape for safety
+                        json = String(json)
+                            .replace(/&/g,'&amp;')
+                            .replace(/</g,'&lt;')
+                            .replace(/>/g,'&gt;');
+                        return '<pre style="white-space:pre-wrap; max-height:260px; overflow:auto;">'+json+'</pre>';
+                    }catch(e){
+                        return '<pre>'+String(air.response_json)+'</pre>';
+                    }
+                }
+            },
             {name:'response_keys', type:'text', locked:true,display:'Response Keys'},
             {name:'response_id', type:'text', display:'openAI response ID',locked:true},
         {section_end:'response'},
         {sidebar_start:'right', collapsed:false},
+            // {section_start:'creator'},
+            // 'creator_type','creator_id',
+            // {section_end:'creator'},
             {section_start:'workflow'},
+            'status',
             'tags',
             {section_end:'workflow'},
             {section_start:'tokens'},

package/server/schemas/task.js

@@ -156,7 +156,8 @@ var task = function(){return{
                 _joe.Sections.unFocusAll();
                 _joe.Sections.setTabbedMode(false);
             }
-        }
+        },
+        // (Deprecated) task-specific Thought trigger kept for backward compatibility if needed
     },
     onPanelShow:function(state){
 
@@ -180,6 +181,8 @@ var task = function(){return{
             {section_start:'JAI',display:'JOE Ai'},
             "objectChat",
             "listConversations",
+            'proposeThought',
+            'ai_responses',
             {section_end:'JAI'},
         {sidebar_end:'left'},
         {section_start:'overview'},