json-object-editor 0.10.650 → 0.10.653

package/server/modules/ThoughtPipeline.js

@@ -392,7 +392,7 @@ ThoughtPipeline.compile = async function compile(pipelineId, scopeId, opts) {
  * @param {string} agentId
  * @param {string} userInput
  * @param {string} scopeId
- * @param {object} ctx - optional context (e.g., { req })
+ * @param {object} ctx - optional context (e.g., { req, model })
  */
 ThoughtPipeline.runAgent = async function runAgent(agentId, userInput, scopeId, ctx) {
     var agent = getAgent(agentId);
@@ -401,8 +401,11 @@ ThoughtPipeline.runAgent = async function runAgent(agentId, userInput, scopeId,
     var apiKey = getAPIKey();
     var openai = new OpenAI({ apiKey: apiKey });
 
+    var overrideModel = ctx && ctx.model;
+    var modelToUse = overrideModel || agent.model || 'gpt-4.1-mini';
+
     var response = await openai.responses.create({
-        model: agent.model || 'gpt-4.1-mini',
+        model: modelToUse,
         instructions: agent.system_prompt,
         input: JSON.stringify({
             pipeline_id: compiled.pipeline_id,
@@ -440,6 +443,15 @@ ThoughtPipeline.runAgent = async function runAgent(agentId, userInput, scopeId,
         name: agent.name + ' → Thoughts',
         response_type: 'thought_generation',
         response: rawText || '',
+        response_json: (function () {
+            try {
+                var jt = extractJsonText(rawText);
+                if (!jt) return null;
+                return JSON.parse(jt);
+            } catch (_e) {
+                return null;
+            }
+        })(),
         response_id: response.id || '',
         user_prompt: userInput || '',
         model_used: agent.model || 'gpt-4.1-mini',
@@ -518,7 +530,9 @@ ThoughtPipeline.runAgent = async function runAgent(agentId, userInput, scopeId,
                 created_by: 'agent:' + agent.id
             },
             source_ai_response: savedResponseId,
-            created_by: 'agent:' + agent.id
+            created_by: 'agent:' + agent.id,
+            creator_type: 'agent',
+            creator_id: agent.id
         };
     }).filter(function (obj) {
         return obj.statement && obj.statement.length;

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.',
@@ -29,9 +30,12 @@ var schema = {
             { 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' }
@@ -61,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:[
@@ -83,7 +198,7 @@ var schema = {
             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({_id:{$in:air.generated_thoughts||[]},itemtype:'thought'});
+            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'},
         
@@ -98,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/thought.js

@@ -1,6 +1,8 @@
+const { methods } = require("./ai_prompt");
+
 var thought = {
     display:'Thought',
-    title: 'Thought | ${thought_type}: ${statement}',
+    title: 'Thought | ${name}',
     info: "Persistent reasoning artifact (hypothesis, synthesis, or link) used to build an auditable world model in JOE.",
     menuicon:`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024">
   <path d="M418.79 152.21c54.1-4.68 106.11 14.11 145.57 50.7 179.88-61.28 357.82 94.91 322.09 281.77-17.7 92.57-93.99 170.46-185.58 191.53-7.83 1.8-34.03 4.23-38 6.47-2.3 1.29-14.64 18.32-18.65 22.27-82.76 81.43-218.9 67.72-286.83-24.62l-35.16 3.37c-205.89-4.36-263.08-280.1-74.73-364.78 10.05-87.72 83.39-159.08 171.29-166.69Zm-39.41 491.05c4.96 4.51 11.22 16.94 16.69 23.33 46.94 54.84 121.44 70.23 186.17 36.84 26.3-13.56 42.96-35.52 62.34-56.84 75.92-4.51 145.19-42.32 182.22-109.5 88.11-159.86-57.37-346.63-233.69-303.07-9.81 2.43-27.09 11.14-35.93 10.11-8.59-1-28.84-22.68-38.58-29.14-86.51-57.47-207.06-11.17-229.88 89.98-3.02 13.37-1.37 36.64-13.02 43.9-16.07 10.02-32.75 13.56-49.51 26.98-116.69 93.45-38.49 282 110.22 268.53 13.11-1.19 31.88-11.21 42.98-1.12Z"/>
@@ -12,7 +14,7 @@ var thought = {
         purpose: 'Use thoughts to store inspectable reasoning: hypotheses to be vetted, syntheses that compress many objects, and binary links (A↔B) with receipts. Thoughts are reusable as context in pipelines and agent runs.',
         labelField: 'name',
         defaultSort: { field: 'joeUpdated', dir: 'desc' },
-        searchableFields: ['name', 'statement', 'info', 'thought_type', 'status', 'relationship_type', 'tags', '_id'],
+        searchableFields: ['name', 'statement', 'info', 'thought_type', 'status', 'relationship_type', 'created_by', 'creator_type', 'creator_id', 'tags', '_id'],
         allowedSorts: ['joeUpdated', 'created', 'thought_type', 'status', 'certainty'],
         relationships: {
             outbound: [
@@ -47,9 +49,11 @@ var thought = {
             { name: 'b', type: 'object' },
             { name: 'relationship_type', type: 'string' },
             { name: 'rationale', type: 'string' },
-            // Lineage / provenance (ai_response_id, created_by, reviewed_by, etc.)
+            // Lineage / provenance (ai_response_id, created_by/creator, reviewed_by, etc.)
             { name: 'source_ai_response', type: 'string', isReference: true, targetSchema: 'ai_response' },
             { name: 'created_by', type: 'string' },
+            { name: 'creator_type', type: 'string', enumValues: ['user','agent'] },
+            { name: 'creator_id', type: 'string' },
             { name: 'lineage', type: 'object' },
             { name: 'joeUpdated', type: 'string', format: 'date-time', required: true },
             { name: 'created', type: 'string', format: 'date-time', required: true }
@@ -68,9 +72,54 @@ var thought = {
         var filters = [];
         // Tag-based filters are the main cross-cutting dimension for Thoughts
         filters = filters.concat(
-            _joe.Filter.Options.tags({ group: 'tags', untagged: true, collapsed: true })
+            _joe.Filter.Options.tags({ group: 'tags', untagged: true, collapsed: true }),
+            _joe.Filter.Options.getDatasetPropertyValues('thought','created_by',{ group: 'created_by', collapsed: true }),
+            _joe.Filter.Options.getDatasetPropertyValues('thought','creator_type',{ group: 'creator_type', collapsed: true })
+            
         );
 
+        // Creator_id filters with human-readable labels
+        try{
+            var dataset = _joe.getDataset('thought') || [];
+            var byCreator = {};
+            dataset.map(function(t){
+                if(!t.creator_id){ return; }
+                var key = t.creator_type+':'+t.creator_id;
+                if(!byCreator[key]){
+                    // Try to resolve a nice display name
+                    var name = t.creator_id;
+                    if(t.creator_type === 'user' && _joe.Data.user){
+                        var u = _joe.Data.user.find(function(x){ return x && x._id === t.creator_id; });
+                        if(u){ name = u.fullname || u.name || u.email || u._id; }
+                    }else if(t.creator_type === 'agent'){
+                        // For agents we only have logical ids like thought_agent_default
+                        name = t.creator_id;
+                    }
+                    byCreator[key] = {
+                        name: name,
+                        filter: { creator_type: t.creator_type, creator_id: t.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){}
+
         // Group thoughts by what they are about (about[].itemtype).
         // We build filters manually so that each itemtype gets its own filter
         // on the nested path "about.itemtype". JOE's search engine treats this
@@ -104,7 +153,7 @@ var thought = {
     },
     listView: {
         title: function (th) {
-            var html = `<joe-subtext>${_joe.Utils.prettyPrintDTS(th.created)}</joe-subtext><joe-title>${th.name}</joe-title>`;
+            var html = `<joe-subtext>${th.created_by} - ${_joe.Utils.prettyPrintDTS(th.created)}</joe-subtext><joe-title>${th.name}</joe-title>`;
             html += `<joe-subtitle>${th.statement}</joe-subtitle>`;
 
             return html;
@@ -237,6 +286,8 @@ var thought = {
             locked: true
         },
         { name: 'created_by', type: 'string', locked: true },
+        { name: 'creator_type', type: 'select', values:['user','agent'], locked: true },
+        { name: 'creator_id', type: 'string', locked: true },
         {
             name: 'lineage',
             type: 'rendering',
@@ -272,6 +323,7 @@ var thought = {
             }
         });
     },
+    methods:{},
     idprop: '_id'
 };
 

package/server/webconfig.js

@@ -21,7 +21,7 @@ var joewebconfig = {
     templatesDir:'_templates',
     //httpsPort:2100,
     default_schemas:['user','group','goal','initiative','event','report','tag','status','workflow','list','notification','note','include','instance','setting',
-        'ai_assistant','ai_conversation','ai_response','ai_tool','ai_prompt','ai_widget_conversation','thought'
+        'ai_assistant','ai_conversation','ai_response','ai_tool','ai_prompt','ai_widget_conversation','ai_pipeline','thought'
     ]
 };