json-object-editor 0.10.653 → 0.10.654

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-object-editor",
-  "version": "0.10.653",
+  "version": "0.10.654",
   "description": "JOE the Json Object Editor | Platform Edition",
   "main": "app.js",
   "scripts": {

package/readme.md

@@ -5,6 +5,15 @@ JOE is software that allows you to manage data models via JSON objects. There ar
 
 
 
+## What’s new in 0.10.654 (brief)
+- OpenAI Files mirrored on S3 upload; uploader tiles show the `openai_file_id`. Retry upload is available per file.
+- Responses integration improvements:
+  - Per‑prompt `attachments_mode` on `ai_prompt` (`direct` vs `file_search`). Direct sends `input_file` parts; file search auto‑creates a vector store and attaches it.
+  - Safe retry if a model rejects `temperature/top_p` (we strip and retry once).
+  - Select Prompt lists prompts by active status where either `datasets[]` or `content_items[].itemtype` matches the current object.
+  - `ai_response` now shows `used_openai_file_ids` and correctly records `referenced_objects` for Select Prompt runs.
+- UX: “Run AI Prompt” and “Run Thought Agent” buttons disable and pulse while running to avoid double‑submits.
+
 ## Architecture & Mental Model (Server)
 
 - Global JOE
@@ -176,18 +185,50 @@ JOE is software that allows you to manage data models via JSON objects. There ar
 - Each Thought run persists an `ai_response` with `response_type:'thought_generation'`, `referenced_objects:[scope_id]`, and `generated_thoughts[]` containing the ids of created Thought records.
 - In any schema UI you can include core fields `proposeThought` and `ai_responses` to (a) trigger a Thought run for the current object and (b) list all related `ai_response` records for audit and reuse.
 
-## File uploads (S3)
+## File uploads (S3 + OpenAI Files)
 - Uploader field options:
   - `allowmultiple: true|false` — allow selecting multiple files.
   - `url_field: 'image_url'` — on success, sets this property to the remote URL and rerenders that field.
   - `ACL: 'public-read'` — optional per-field ACL. When omitted, server currently defaults to `public-read` (temporary during migration).
 - Flow:
   - Client posts `{ Key, base64, contentType, ACL? }` to `/API/plugin/awsConnect`.
-  - Server uploads with AWS SDK v3 and returns `{ url, Key, bucket, etag }` (HTTP 200).
-  - Client uses `response.url`; if `url_field` is set, it assigns and rerenders that field.
+  - Server uploads to S3 (AWS SDK v3) and, if `OPENAI_API_KEY` is configured, also uploads the same bytes to OpenAI Files (purpose=`assistants`).
+  - Response shape: `{ url, Key, bucket, etag, openai_file_id?, openai_purpose?, openai_error? }`.
+  - Client:
+    - Sets the `url` on the file object; if `url_field` is set on the schema field, it assigns that property and rerenders.
+    - Persists OpenAI metadata on the file object: `openai_file_id`, `openai_purpose`, `openai_status`, `openai_error`.
+    - Renders the OpenAI file id under the filename on each uploader tile. The “OpenAI: OK” banner has been removed.
+    - Shows a per‑file “Upload to OpenAI” / “Retry OpenAI” action when no id is present or when an error occurred. This calls `POST /API/plugin/chatgpt/filesRetryFromUrl` with `{ url, filename, contentType }` and updates the file metadata.
 - Errors:
   - If bucket or region config is missing, server returns 400 with a clear message.
   - If the bucket has ACLs disabled, server returns 400: “Bucket has ACLs disabled… remove ACL or switch to presigned/proxy access.”
+  - If OpenAI upload fails, the uploader shows `OpenAI error: <message>` inline; you can retry from the file row.
+
+- Using OpenAI file ids:
+  - File ids are private; there is no public URL to view them.
+  - Use the OpenAI Files API (with your API key) to retrieve metadata or download content:
+    - Metadata: `GET /v1/files/{file_id}`
+    - Content: `GET /v1/files/{file_id}/content`
+  - Node example:
+    ```js
+    const OpenAI = require('openai');
+    const fs = require('fs');
+    const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+    const meta = await client.files.retrieve('file_abc123');
+    const stream = await client.files.content('file_abc123');
+    const buf = Buffer.from(await stream.arrayBuffer());
+    fs.writeFileSync('downloaded.bin', buf);
+    ```
+
+### Related endpoints (server/plugins)
+
+- `POST /API/plugin/awsConnect` – S3 upload (and OpenAI mirror when configured)
+  - Input: `{ Key, base64, contentType, ACL? }`
+  - Output: `{ url, Key, bucket, etag, openai_file_id?, openai_purpose?, openai_error? }`
+
+- `POST /API/plugin/chatgpt/filesRetryFromUrl` – (Re)upload an existing S3 file to OpenAI
+  - Input: `{ url, filename?, contentType? }`
+  - Output: `{ success, openai_file_id?, openai_purpose?, error? }`
 
 ## SERVER/PLATFORM mode
 	check port 2099

package/server/fields/core.js

@@ -143,7 +143,7 @@ var fields = {
         }
         return 'new item';
     }},
-    status:{type:'select',rerender:'status',icon:'status',
+    status:{type:'select',rerender:'status',icon:'status',reloadable:true,
         after:function(item){
             if(item.joeUpdated){
                 var cont =`
@@ -523,6 +523,7 @@ var fields = {
         type: "select",
         display: "Ai Model",
         values: [
+            {value:"gpt-5.2", name: "GPT-5.2 (Strong, 128k)" },
             { value:"gpt-5.1", name: "GPT-5.1 (Strong, 128k)" },
             { value:"gpt-5", name: "GPT-5 (Strong, 128K)" },
             { value:"gpt-5-mini", name: "GPT-5-mini (Cheap, 1M)" },
@@ -533,11 +534,13 @@ var fields = {
             { value: "gpt-4.1-nano", name: "4.1-nano (Fastest, light tasks)" }
           ],
           tooltip:`Ai Model Guide -
-            GPT-4o is the default for fast, responsive tasks and supports up to 128k tokens. It’s ideal for short completions, summaries, and dynamic UI tools.
+          GPT-5.2 is the default for strong, 128k token tasks. It’s ideal for complex analysis, large datasets, and detailed reasoning.
+          GPT-5-mini is the default for cheap, 1M token tasks. It’s ideal for quick completions, summaries, and dynamic UI tools.
+            GPT-4o is , responsive tasks and supports up to 128k tokens. It’s ideal for short completions, summaries, and dynamic UI tools.
             GPT-4.1 and 4.1-mini support a massive 1 million token context, making them perfect for large inputs like full business profiles, long strategy texts, and multi-object analysis.
             4.1-mini is significantly cheaper than full 4.1, with great balance for most structured AI workflows.
             4.1-nano is best for lightweight classification or routing logic where speed and cost matter more than depth.`,
-        default: "gpt-4o",
+        default: "gpt-5-mini",
       },
     objectChat:{
         type:'button',
@@ -560,10 +563,50 @@ var fields = {
             return _joe.schemas.ai_response.methods.listResponses(obj);
         }
     },
+    select_prompt:{
+        display:'Run AI Prompt',
+        type:'content',
+        reloadable:true,
+        icon:'ai_prompt',
+        run:function(obj){
+            if(!obj || !obj._id){
+                return '<joe-text>Save this item before running AI prompts.</joe-text>';
+            }
+            var itemtype = obj.itemtype || (_joe.current && _joe.current.schema && _joe.current.schema.name) || null;
+            // Active ai_prompt statuses
+            var activeStatuses = (_joe.getDataset('status')||[]).filter(function(s){
+                return Array.isArray(s.datasets) && s.datasets.includes('ai_prompt') && s.active;
+            }).map(function(s){ return s._id; });
+            // Filter prompts by dataset match (datasets[] OR content_items[].itemtype) and active
+            var prompts = (_joe.getDataset('ai_prompt')||[]).filter(function(p){
+                var okStatus = !p.status || activeStatuses.indexOf(p.status) !== -1;
+                var matchByContentItems = (p.content_items||[]).some(function(ci){ return ci && ci.itemtype === itemtype; });
+                var matchByDatasets = Array.isArray(p.datasets) && p.datasets.indexOf(itemtype) !== -1;
+                var okDataset = matchByContentItems || matchByDatasets;
+                return okStatus && okDataset;
+            });
+            var selId = 'select_prompt_'+obj._id;
+            var filesSelId = 'select_prompt_files_'+obj._id;
+            var html = '';
+            html += '<div class="joe-field-comment">Select prompt</div>';
+            html += '<select id="'+selId+'" style="width:100%;">';
+            prompts.forEach(function(p){
+                var name = (p && p.name) || '';
+                html += '<option value="'+p._id+'">'+name+'</option>';
+            });
+            html += '</select>';
+            html += '<div class="joe-field-comment" style="margin-top:8px;">Attach files (optional)</div>';
+            html += '<select id="'+filesSelId+'" multiple class="joe-prompt-select"></select>';
+            html += '<script>(function(){ try{ _joe && _joe.Ai && _joe.Ai.renderFilesSelector && _joe.Ai.renderFilesSelector("'+filesSelId+'",{ cap:10, disableWithoutOpenAI:true }); }catch(e){} })();</script>';
+			html += '<joe-button class="joe-button joe-ai-button joe-iconed-button" onclick="_joe.Ai.runPromptSelection(this,\''+obj._id+'\',\''+selId+'\',\''+filesSelId+'\')">Run AI Prompt</joe-button>';
+            return html;
+        }
+    },
     proposeThought:{
         display:'Propose Thought',
         type:'content',
         reloadable:true,
+        icon:'ai_thought',
         run:function(obj){
             if (!obj || !obj._id) {
                 return '<joe-text>Save this item before proposing Thoughts.</joe-text>';
@@ -584,9 +627,14 @@ var fields = {
                 'Avoid meta-thoughts about prompts or schemas.'
             );
             var taId = 'propose_thought_prompt_' + obj._id;
+            var selId = 'propose_thought_files_' + obj._id;
             var html = '';
             html += '<div class="joe-field-comment">Thought prompt</div>';
-            html += '<textarea id="'+taId+'" style="width:100%;min-height:80px;">'+defaultPrompt+'</textarea>';
+            html += '<textarea id="'+taId+'" class="joe-prompt-textarea">'+defaultPrompt+'</textarea>';
+            // Attach files selector (optional)
+            html += '<div class="joe-field-comment" style="margin-top:8px;">Attach files (optional)</div>';
+            html += '<select id="'+selId+'" class="joe-prompt-select" multiple></select>';
+            html += '<script>(function(){ try{ _joe && _joe.Ai && _joe.Ai.renderFilesSelector && _joe.Ai.renderFilesSelector("'+selId+'",{ cap:10, disableWithoutOpenAI:true }); }catch(e){} })();</script>';
             // For now, use the generic Thought agent; scope_id is the current object id.
             var args = "'" + obj._id + "','" + taId + "'";
             if (fieldDef && fieldDef.model) {
@@ -594,8 +642,8 @@ var fields = {
                 var m = String(fieldDef.model).replace(/'/g, "\\'");
                 args += ",'" + m + "'";
             }
-            html += '<joe-button class="joe-button joe-ai-button joe-iconed-button" ';
-            html += 'onclick="_joe.Ai.runProposeThought('+ args +')">Run Thought Agent</joe-button>';
+			html += '<joe-button class="joe-button joe-ai-button joe-iconed-button" ';
+			html += 'onclick="_joe.Ai.runProposeThought(this,'+ args +')">Run Thought Agent</joe-button>';
             return html;
         }
     },

package/server/modules/MCP.js

@@ -696,8 +696,8 @@ MCP.tools = {
   },
 
   // Run a thought agent (pipeline + Responses API) and materialize proposed Thoughts.
-  runThoughtAgent: async ({ agent_id, user_input, scope_id, model } = {}, ctx = {}) => {
-    const context = Object.assign({}, ctx, { model });
+  runThoughtAgent: async ({ agent_id, user_input, scope_id, model, openai_file_ids } = {}, ctx = {}) => {
+    const context = Object.assign({}, ctx, { model, openai_file_ids });
     const result = await ThoughtPipeline.runAgent(agent_id, user_input, scope_id, context);
     return result;
   },

package/server/modules/ThoughtPipeline.js

@@ -460,6 +460,12 @@ ThoughtPipeline.runAgent = async function runAgent(agentId, userInput, scopeId,
         usage: response.usage || {},
         prompt_method: 'ThoughtPipeline.runAgent'
     };
+    // Persist used OpenAI file ids when provided (audit convenience)
+    try{
+        if (ctx && Array.isArray(ctx.openai_file_ids) && ctx.openai_file_ids.length){
+            aiResponseObj.used_openai_file_ids = ctx.openai_file_ids.slice(0,10);
+        }
+    }catch(_e){}
 
     var savedResponse = await new Promise(function (resolve, reject) {
         try {

package/server/plugins/awsConnect.js

@@ -3,6 +3,7 @@ function AWSConnect(){
 this.default = function(data,req,res){
     // AWS SDK v3 (modular)
 const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');
+const chatgpt = require('./chatgpt.js');
 var settings_config = tryEval(JOE.Cache.settings.AWS_S3CONFIG)||{};
 var config = $c.merge(settings_config);
 
@@ -67,12 +68,41 @@ var response = {
     }
 
     s3.send(new PutObjectCommand(s3Params))
-        .then(function(data){
+        .then(async function(data){
             // Construct canonical URL from region + bucket
             var region = config.region;
             var url = 'https://'+Bucket+'.s3.'+region+'.amazonaws.com/'+Key;
             response.data = data;
             response.url = url;
+            response.etag = data && (data.ETag || data.ETAG || data.eTag);
+
+            // If OpenAI key is configured, also upload to OpenAI Files (purpose: assistants)
+            try{
+                var hasOpenAIKey = !!JOE.Utils.Settings && !!JOE.Utils.Settings('OPENAI_API_KEY');
+                if(hasOpenAIKey){
+                    // Prefer original buffer when provided via base64
+                    if(data && typeof data === 'object'){ /* noop to keep linter happy */}
+                    if(typeof s3Params.Body !== 'string' && s3Params.Body){
+                        var filenameOnly = Key.split('/').pop();
+                        var result = await chatgpt.filesUploadFromBufferHelper({
+                            buffer: s3Params.Body,
+                            filename: filenameOnly,
+                            contentType: s3Params.ContentType,
+                            purpose: 'assistants'
+                        });
+                        if(result && result.id){
+                            response.openai_file_id = result.id;
+                            response.openai_purpose = result.purpose || 'assistants';
+                        }
+                    }else{
+                        // Fallback: if we didn't have a buffer (unlikely with current flow),
+                        // skip immediate upload; client can use retry endpoint.
+                    }
+                }
+            }catch(e){
+                // Non-fatal: S3 upload already succeeded
+                response.openai_error = (e && e.message) || String(e);
+            }
             res.status(200).send(response);
             console.log("Successfully uploaded data to "+Key);
         })

package/server/plugins/chatgpt.js

@@ -1,6 +1,8 @@
 const OpenAI = require("openai");
 const { google } = require('googleapis');
 const path = require('path');
+const os = require('os');
+const fs = require('fs');
 const MCP = require("../modules/MCP.js");
 // const { name } = require("json-object-editor/server/webconfig");
 
@@ -413,6 +415,109 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
     function newClient() {
     return new OpenAI({ apiKey: getAPIKey() });
     }
+
+    // Safely call Responses API with optional temperature/top_p.
+    // If the model rejects these parameters, strip and retry once.
+    async function safeResponsesCreate(openai, payload){
+        try{
+            return await openai.responses.create(payload);
+        }catch(e){
+            try{
+                var msg = (e && (e.error && e.error.message) || e.message || '').toLowerCase();
+                var badTemp = msg.includes("unsupported parameter") && msg.includes("temperature");
+                var badTopP = msg.includes("unsupported parameter") && msg.includes("top_p");
+                var unknownTemp = msg.includes("unknown parameter") && msg.includes("temperature");
+                var unknownTopP = msg.includes("unknown parameter") && msg.includes("top_p");
+                if (badTemp || badTopP || unknownTemp || unknownTopP){
+                    var p2 = Object.assign({}, payload);
+                    if (p2.hasOwnProperty('temperature')) delete p2.temperature;
+                    if (p2.hasOwnProperty('top_p')) delete p2.top_p;
+                    console.warn('[chatgpt] Retrying without temperature/top_p due to model rejection');
+                    return await openai.responses.create(p2);
+                }
+            }catch(_e){ /* fallthrough */ }
+            throw e;
+        }
+    }
+
+    // Ensure a vector store exists with the provided file_ids indexed; returns { vectorStoreId }
+    async function ensureVectorStoreForFiles(fileIds = []){
+        const openai = newClient();
+        // Create ephemeral store per run (could be optimized to reuse/persist later)
+        const vs = await openai.vectorStores.create({ name: 'JOE Prompt Run '+Date.now() });
+        const storeId = vs.id;
+        // Link files by id
+        for (const fid of (fileIds||[]).slice(0,10)) {
+            try{
+                await openai.vectorStores.files.create(storeId, { file_id: fid });
+            }catch(e){
+                console.warn('[chatgpt] vectorStores.files.create failed for', fid, e && e.message || e);
+            }
+        }
+        // Poll (best-effort) until files are processed or timeout
+        const timeoutMs = 8000;
+        const start = Date.now();
+        try{
+            while(Date.now() - start < timeoutMs){
+                const listed = await openai.vectorStores.files.list(storeId, { limit: 100 });
+                const items = (listed && listed.data) || [];
+                const pending = items.some(f => f.status && f.status !== 'completed');
+                if(!pending){ break; }
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }catch(_e){ /* non-fatal */ }
+        return { vectorStoreId: storeId };
+    }
+
+    // ---------------- OpenAI Files helpers ----------------
+    async function uploadFileFromBuffer(buffer, filename, contentType, purpose) {
+        const openai = newClient();
+        const usePurpose = purpose || 'assistants';
+        const tmpDir = os.tmpdir();
+        const safeName = filename || ('upload_' + Date.now());
+        const tmpPath = path.join(tmpDir, safeName);
+        await fs.promises.writeFile(tmpPath, buffer);
+        try {
+            // openai.files.create accepts a readable stream
+            const fileStream = fs.createReadStream(tmpPath);
+            const created = await openai.files.create({
+                purpose: usePurpose,
+                file: fileStream
+            });
+            return { id: created.id, purpose: usePurpose };
+        } finally {
+            // best-effort cleanup
+            fs.promises.unlink(tmpPath).catch(()=>{});
+        }
+    }
+
+    // Expose a helper that other plugins can call in-process
+    this.filesUploadFromBufferHelper = async function ({ buffer, filename, contentType, purpose }) {
+        if (!buffer || !buffer.length) {
+            throw new Error('Missing buffer');
+        }
+        return await uploadFileFromBuffer(buffer, filename, contentType, purpose || 'assistants');
+    };
+
+    // Public endpoint to retry OpenAI upload from a URL (e.g., S3 object URL)
+    this.filesRetryFromUrl = async function (data, req, res) {
+        try {
+            const { default: got } = await import('got');
+            const url = data && (data.url || data.location);
+            const filename = data && data.filename || (url && url.split('/').pop()) || ('upload_' + Date.now());
+            const contentType = data && data.contentType || undefined;
+            const purpose = 'assistants';
+            if (!url) {
+                return { success: false, error: 'Missing url' };
+            }
+            const resp = await got(url, { responseType: 'buffer' });
+            const buffer = resp.body;
+            const created = await uploadFileFromBuffer(buffer, filename, contentType, purpose);
+            return { success: true, openai_file_id: created.id, openai_purpose: created.purpose };
+        } catch (e) {
+            return { success: false, error: e && e.message || 'Retry upload failed' };
+        }
+    };
     this.testPrompt= async function(data, req, res) {
         try {
             var payload = {
@@ -839,7 +944,8 @@ 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;
+        // Support both payload shapes: { ai_prompt, params:{...}, ... } and flat
+        const params = (data && (data.params || data)) || {};
 
         if (!promptId) {
             return { error: "Missing prompt_id." };
@@ -908,8 +1014,49 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             //return_token_usage: true
             //max_tokens: prompt.max_tokens ?? 1200
           };
-          
-          const response = await openai.responses.create(payload);
+          coloredLog(`${payload.model} and ${payload.temperature}`);
+          const mode = (prompt.attachments_mode || 'direct');
+          if (Array.isArray(data.openai_file_ids) && data.openai_file_ids.length){
+            if (mode === 'file_search'){
+              // Use file_search tool and attach vector store
+              try{
+                const ensured = await ensureVectorStoreForFiles(data.openai_file_ids);
+                payload.tools = payload.tools || [];
+                if(!payload.tools.find(t => t && t.type === 'file_search')){
+                  payload.tools.push({ type:'file_search' });
+                }
+                payload.tool_resources = Object.assign({}, payload.tool_resources, {
+                  file_search: { vector_store_ids: [ ensured.vectorStoreId ] }
+                });
+                // Keep input as text only (if any)
+                if (finalInput && String(finalInput).trim().length){
+                  payload.input = finalInput;
+                }
+              }catch(e){
+                console.warn('[chatgpt] file_search setup failed; falling back to direct parts', e && e.message || e);
+                // Fall back to direct parts
+                const parts = [];
+                if (finalInput && String(finalInput).trim().length){
+                  parts.push({ type:'input_text', text: String(finalInput) });
+                }
+                data.openai_file_ids.slice(0,10).forEach(function(id){
+                  parts.push({ type:'input_file', file_id: id });
+                });
+                payload.input = [ { role:'user', content: parts } ];
+              }
+            } else {
+              // Direct context stuffing: input parts
+              const parts = [];
+              if (finalInput && String(finalInput).trim().length){
+                parts.push({ type:'input_text', text: String(finalInput) });
+              }
+              data.openai_file_ids.slice(0,10).forEach(function(id){
+                parts.push({ type:'input_file', file_id: id });
+              });
+              payload.input = [ { role:'user', content: parts } ];
+            }
+          }
+          const response = await safeResponsesCreate(openai, payload);
 
 
         // const payload = createResponsePayload(prompt, params, instructions, data.user_prompt);
@@ -927,6 +1074,14 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             user: req && req.User,
             ai_assistant_id: data.ai_assistant_id
         });
+        try{
+            if (saved && Array.isArray(data.openai_file_ids) && data.openai_file_ids.length){
+                saved.used_openai_file_ids = data.openai_file_ids.slice(0,10);
+                await new Promise(function(resolve){ 
+                    JOE.Storage.save(saved,'ai_response',function(){ resolve(); },{ user: req && req.User, history:false });
+                });
+            }
+        }catch(_e){}
 
         return { success: true, ai_response_id: saved._id,response:response.output_text || "",usage:response.usage };
     } catch (e) {
@@ -1331,6 +1486,7 @@ this.executeJOEAiPrompt = async function(data, req, res) {
         widgetHistory: this.widgetHistory,
         widgetMessage: this.widgetMessage,
         autofill: this.autofill,
+        filesRetryFromUrl: this.filesRetryFromUrl
     };
     this.protected = [,'testPrompt'];
     return self;

package/server/schemas/ai_prompt.js

@@ -29,6 +29,7 @@ var schema = {
             { name:'instructions_format', type:'string' },
             { name:'instructions', type:'string' },
             { name:'user_prompt', type:'string' },
+            { name:'attachments_mode', type:'string', display:'Attachments Mode', enumValues:['direct','file_search'], default:'direct' },
             { name:'status', type:'string', isReference:true, targetSchema:'status' },
             { name:'tags', type:'string', isArray:true, isReference:true, targetSchema:'tag' },
             { name:'ai_model', type:'string' },
@@ -162,6 +163,7 @@ var schema = {
         {section_end:'workflow'},
         {section_start:'openAi',collapsed:true},
             'ai_model',
+            {name:'attachments_mode', type:'select', display:'Attachments Mode', values:['direct','file_search'], default:'direct', comment:'direct = include files in prompt as context; file_search = index files and retrieve relevant chunks'},
             {name:'temperature', type:'number',display:'Temperature', default:.7, step:"0.1",comment:'0-1, 0 is deterministic, 1 is random'},
             //{name:'max_tokens', type:'number',display:'Max Tokens',comment:'max tokens to return',default:4096},
         {section_end:'openAi'},

package/server/schemas/ai_response.js

@@ -34,6 +34,7 @@ var schema = {
             { name:'response_keys', type:'string', isArray:true },
             { name:'response_id', type:'string' },
             { name:'usage', type:'object' },
+            { name:'used_openai_file_ids', type:'string', isArray:true },
             // { name:'creator_type', type:'string', enumValues:['user','ai_assistant'] },
             // { name:'creator_id', type:'string' },
             { name:'tags', type:'string', isArray:true, isReference:true, targetSchema:'tag' },
@@ -66,8 +67,9 @@ var schema = {
         listWindowTitle: 'Ai Responses'
     },
     subsets: function(a,b,c){
+        var subsets = [];
         // Base subsets: tag-based and by ai_prompt
-        var subsets = _joe.Filter.Options.tags({group:true,collapsed:false}).concat(
+        var subsets = subsets.concat(
             _joe.getDataset('ai_prompt').map(function(prompt){
                 var color = prompt.status && $J.get(prompt.status,'status').color;
                 return {
@@ -103,17 +105,9 @@ var schema = {
                     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'
-        //     }
-        // );
+        }catch(_e){  }
+        //add status subsets
+        subsets = subsets.concat(_joe.Filter.Options.status({group:'status'}));
         return subsets;
       },
       stripeColor:function(air){
@@ -122,6 +116,15 @@ var schema = {
         }
         return null;
       },
+      bgColor:function(air){//status color
+        if(air.status){
+            var status = _joe.getDataItem(air.status,'status');
+            if(status && status.color){
+                return {color:status.color,title:status.name};
+            }
+        }
+        return null;
+      },
     filters:function(){
         var filters = [];
         // Tag filters
@@ -247,6 +250,12 @@ var schema = {
             },
             {name:'response_keys', type:'text', locked:true,display:'Response Keys'},
             {name:'response_id', type:'text', display:'openAI response ID',locked:true},
+            {name:'used_openai_file_ids', type:'content', display:'OpenAI File IDs (Used)', locked:true, run:function(air){
+                var ids = air && air.used_openai_file_ids;
+                if(!ids || !ids.length){ return '<joe-subtext>None</joe-subtext>'; }
+                return ids.map(function(id){ return '<joe-subtext>'+id+'</joe-subtext>'; }).join('');
+            }},
+           
         {section_end:'response'},
         {sidebar_start:'right', collapsed:false},
             // {section_start:'creator'},

package/server/schemas/status.js

@@ -67,7 +67,15 @@ var schema = {
         return false;
 
     },
-    subsets:function(){
+    subsets:function(){//active, inactive, terminal, default
+        return [
+            {name:'active',filter:{active:true}},
+            {name:'inactive',filter:{inactive:true}},
+            {name:'terminal',filter:{terminal:true}},
+            {name:'default',filter:{default:true}}
+        ];
+    },
+    filters:function(){
         var schemas = [];
         var subs = [];
         _joe.current.list.map(function(status){
@@ -83,7 +91,9 @@ var schema = {
         'name',
         'info',
         'description',
-        'color:color',
+        {name:'color',type:'color',comment:'hex or html color code',reloadable:true,
+            ai:{prompt:'generate a hex color code for this status. prioritise the name and info fields for context. Override with a color name is one is set.'}
+        },
         { name: "index", type: "number", display: "Ordering Index", comment: "Optional manual ordering index for lists and workflows. Lower values appear first.", width:'50%' },
 
         { name: "code", type: "text", display: "System Code", comment: "Machine-usable, human-readable identifier for database/API use. Use lowercase with underscores.", width:'50%' },

package/server/schemas/task.js

@@ -178,12 +178,16 @@ var task = function(){return{
     fields:function(){
         var fields = [
             {sidebar_start:'left'},
-            {section_start:'JAI',display:'JOE Ai'},
+            {section_start:'ai_chat', anchor:'AiChat'},
             "objectChat",
             "listConversations",
+            {section_end:'ai_chat'},
+            {section_start:'ai_thoughts', anchor:'AiThoughts'},
             'proposeThought',
+            {section_end:'ai_thoughts'},
+            {section_start:'ai_responses', anchor:'AiResponses',collapsed:true},
             'ai_responses',
-            {section_end:'JAI'},
+            {section_end:'ai_responses'},
         {sidebar_end:'left'},
         {section_start:'overview'},
             'name',
@@ -250,7 +254,9 @@ var task = function(){return{
         {section_start:'acceptance',collapsed:function(item){
             return !(item.scceptance_criteria && item.scceptance_criteria.length);
         }},
-            {name:'scceptance_criteria',display:'acceptance criteria',type:'objectList',label:false,
+            {name:'acceptance_criteria',display:'acceptance criteria',type:'objectList',label:false,value:function(item){
+                return item.scceptance_criteria || [];
+            },
             template:function(obj,subobj){
                 var done = (subobj.sub_complete)?'joe-strike':'';
                 return '<joe-title class="'+done+'">${criteria}</joe-title>' ;