json-object-editor 0.10.650 → 0.10.654

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',
@@ -448,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 {
@@ -518,7 +536,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/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 = {
@@ -432,7 +537,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 +636,7 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
             response: chatContent,
             payload,
             prompt_method:req.params.method
-        });
+        }, req && req.User);
         coloredLog("response saved -"+responseName);
         return {payload,
             businessOBJ,
@@ -549,8 +687,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 +706,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) => {
@@ -796,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." };
@@ -865,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);
@@ -880,8 +1070,18 @@ 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
         });
+        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) {
@@ -903,13 +1103,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 +1138,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 +1148,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) => {
@@ -1262,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_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_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'},