json-object-editor 0.10.521 → 0.10.622

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-object-editor",
-  "version": "0.10.521",
+  "version": "0.10.622",
   "description": "JOE the Json Object Editor | Platform Edition",
   "main": "app.js",
   "scripts": {
@@ -30,7 +30,8 @@
   },
   "homepage": "http://craydent.com/JsonObjectEditor/docs.html",
   "dependencies": {
-    "aws-sdk": "^2.358.0",
+    "@aws-sdk/client-s3": "^3.927.0",
+    "@aws-sdk/client-ses": "^3.927.0",
     "basic-auth": "^1.0.3",
     "body-parser": "^1.18.3",
     "compression": "^1.7.3",
@@ -43,9 +44,8 @@
     "mailgun": "^0.5.0",
     "mongojs": "^2.3.0",
     "mysql": "^2.16.0",
-    "nodemailer": "^2.7.2",
-    "nodemailer-ses-transport": "^1.4.0",
-    "openai": "^5.23.2",
+    "nodemailer": "^6.10.1",
+    "openai": "^6.9.0",
     "opener": "^1.4.3",
     "pem": "^1.13.2",
     "plaid": "^13.1.0",

package/readme.md

@@ -155,6 +155,19 @@ JOE is software that allows you to manage data models via JSON objects. There ar
   - If you see a payload like `{ originalURL: "/...", site: "no site found" }`, the request hit the Sites catch-all. Ensure MCP routes are initialized before Sites (handled by default in `server/init.js` via `MCP.init()`), and use the correct URL: `/.well-known/mcp/manifest.json` or `/mcp`.
   - To update contact email on /privacy and /terms, set Setting `PRIVACY_CONTACT`.
 
+## File uploads (S3)
+- 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.
+- 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.”
+
 ## SERVER/PLATFORM mode
 	check port 2099
 	/JOE/
@@ -310,6 +323,7 @@ Properties for all Fields
     - `'section_label`:use instead of section_start for display name
     - `section_end`: name/id of section(str)
     - template: html template for fillTemplate(template,current_object);
+    - Note: for fields, `condition` removes the field from the DOM while `hidden` only toggles visibility; sections use `condition` (and sidebar sections use `hidden`) differently than fields.
     
 ##page sidebar
     {sidebar_start: 'SectionName',
@@ -518,9 +532,132 @@ Use these helpers to quickly generate subset/filter options and add per-item str
 
 ### e | exporting an object in pretty format json (or minified)
 JOE.exportJSON = function(object,objvarname,minify)
-
+		
 ##Useful Functions
 _joe.reload(hideMessage,specs)
 - use specs.overwreite object to extend reloaded object.
+		
+_joe.constructObjectFromFields()
+
+## AI / Chat Integrations (OpenAI Responses + Assistants)
+
+JOE ships a few plugins and schemas to help you connect OpenAI assistants and the new Responses API to your data model.
+
+- **`chatgpt` plugin**
+  - Central entry point for OpenAI calls (uses the `openai` Node SDK and the Responses API).
+  - Looks up the OpenAI API key from the `setting` schema:
+    - `OPENAI_API_KEY`: your secret key (can be a service‑account key, e.g. `sk-svcacct-...`).
+  - Key methods:
+    - **`autofill`** (`POST /API/plugin/chatgpt/autofill`):
+      - Given `{ object_id, schema, fields, prompt?, assistant_id?, model? }`, calls `openai.responses.create(...)` and returns a JSON patch for the requested fields only.
+      - Used by `_joe.Ai.populateField(...)` for schema‑driven “AI fill” buttons.
+    - **`executeJOEAiPrompt`**:
+      - Drives the `ai_prompt` → `ai_response` workflow using Responses API + optional helper functions.
+    - **Widget‑focused methods**:
+      - `widgetStart`, `widgetMessage`, `widgetHistory` for the embeddable AI widget (see below).
+
+- **`chatgpt-assistants` plugin (legacy Assistants API)**
+  - Manages the older `beta.assistants` / `beta.threads` API for JOE’s rich in‑app chat (`<joe-ai-chatbox>`).
+  - Still used by the `ai_conversation` flow; new integrations should prefer the Responses‑based `chatgpt` plugin.
+
+- **`chatgpt-tools` plugin**
+  - Exposes JOE “AI tools” configured via the `ai_tool` schema.
+  - Useful when you want OpenAI tools that call back into JOE (e.g. search, profile, etc.).
+
+### AI Assistant schemas
+
+- **`ai_assistant` schema**
+  - Represents a JOE‑side “assistant config” that can be synced to an OpenAI assistant.
+  - Key fields:
+    - `ai_model`: default model (e.g. `gpt-4.1-mini`, `gpt-4o`).
+    - `instructions`: system prompt for the assistant.
+    - `assistant_id`: OpenAI assistant ID (`asst_...`) set by the sync button.
+    - `file_search_enabled`, `code_interpreter_enabled`: toggle built‑in tools.
+    - `tools`: JSON definition array for custom function tools.
+    - `assistant_thinking_text`: what the UI shows while the assistant is “thinking”.
+  - UI highlights the **default assistant**:
+    - The assistant whose `_id` matches the `DEFAULT_AI_ASSISTANT` setting is given a golden stripe in list view.
+  - Default assistant resolution:
+    - The client helper `Ai.getDefaultAssistant()` in `joe-ai.js` looks up `_joe.Data.setting.where({ name: 'DEFAULT_AI_ASSISTANT' })[0]` and caches it.
+
+- **`ai_widget_conversation` schema**
+  - Lightweight conversation log used by the new embeddable widget (`<joe-ai-widget>`).
+  - Fields:
+    - `model`: model name used for the conversation (or inherited from `ai_assistant.ai_model`).
+    - `assistant`: optional reference to the JOE `ai_assistant` used.
+    - `assistant_id`: OpenAI assistant ID (`asst_...`) used by the Responses API.
+    - `system`: effective system prompt.
+    - `messages`: JSON array of `{ role, content, created_at }` for the widget chat.
+    - `last_message_at`, `source`, `tags`, standard system fields.
+  - This schema is what the widget endpoints in `chatgpt` read/write.
+
+### Embeddable AI Widget (`<joe-ai-widget>`)
+
+JOE includes a small web component, defined in `js/joe-ai.js`, that can be dropped into any web page and talks to your JOE instance via the `chatgpt` plugin.
+
+- **Custom element**: `<joe-ai-widget>`
+  - Attributes:
+    - `endpoint` (optional): Base URL to the JOE instance. Defaults to same origin.  
+      Example: `endpoint="https://my-joe.example.com"`.
+    - `ai_assistant_id` (optional): `_id` of an `ai_assistant` document in JOE. If present, the server will load this assistant and use its `ai_model`, `instructions`, and `assistant_id` when starting the conversation.
+    - `assistant_id` (optional): Direct OpenAI assistant ID (`asst_...`). If provided, the widget uses Responses API with `assistant_id` instead of a bare `model`.
+    - `model` (optional): Model name to use when no assistant is supplied (e.g. `gpt-4.1-mini`).
+    - `title` (optional): Header title text shown in the widget panel.
+    - `placeholder` (optional): Input placeholder text.
+    - `source` (optional): Arbitrary string stored on the conversation (`ai_widget_conversation.source`).
+    - `conversation_id` (optional): Existing `ai_widget_conversation._id` to resume a saved chat.
+  - Behavior:
+    - On first attach:
+      - If `conversation_id` is set → calls `GET /API/plugin/chatgpt/widgetHistory?conversation_id=...` and renders messages.
+      - Otherwise → calls `POST /API/plugin/chatgpt/widgetStart` to create a new `ai_widget_conversation` and stores the returned `conversation_id` (and any `assistant_id`/`model`) as attributes.
+    - On send:
+      - Optimistically appends a `{ role:'user', content }` message in the UI.
+      - Calls `POST /API/plugin/chatgpt/widgetMessage` with `{ conversation_id, content, role:'user', assistant_id?, model? }`.
+      - Renders the updated `messages` and assistant reply from the response.
+
+- **Server endpoints (`chatgpt` plugin)**:
+  - `POST /API/plugin/chatgpt/widgetStart` → `chatgpt.widgetStart(data)`
+    - Input: `{ model?, ai_assistant_id?, source? }`.
+    - Behavior:
+      - If `ai_assistant_id` is provided, loads that `ai_assistant` and seeds `model`, `assistant_id`, `system` from it.
+      - Creates `ai_widget_conversation` with empty `messages` and timestamps.
+      - Returns `{ success, conversation_id, model, assistant_id }`.
+  - `GET /API/plugin/chatgpt/widgetHistory?conversation_id=...` → `chatgpt.widgetHistory(data)`
+    - Input: `{ conversation_id }`.
+    - Returns `{ success, conversation_id, model, assistant_id, messages }`.
+  - `POST /API/plugin/chatgpt/widgetMessage` → `chatgpt.widgetMessage(data)`
+    - Input: `{ conversation_id, content, role='user', assistant_id?, model? }`.
+    - Behavior:
+      - Loads `ai_widget_conversation`, appends a user message.
+      - Calls `openai.responses.create`:
+        - With `assistant_id` if available (preferred), or
+        - With `model` and `instructions` (from `system`) otherwise.
+      - Appends an assistant message, updates `last_message_at`, saves the conversation.
+      - Returns `{ success, conversation_id, model, assistant_id, messages, last_message, usage }`.
+
+### AI Widget Test Page
+
+To help you develop and debug the widget + plugin in your instance, JOE exposes an auth‑protected test page, similar to the MCP test pages.
+
+- **Routes** (both require standard JOE `auth`):
+  - `/ai-widget-test.html`
+  - `${JOE.webconfig.joepath}ai-widget-test.html` (e.g. `/JsonObjectEditor/ai-widget-test.html`).
+
+- **Behavior** (`server/modules/Server.js`):
+  - The route handler:
+    - Reads `assistant_id` or `assistant` from the query string.
+    - If not present, tries to resolve the default assistant via:
+      - `JOE.Utils.Settings('DEFAULT_AI_ASSISTANT', { object: true })` and uses its `.value` as `ai_assistant_id`.
+    - Renders a small HTML page that:
+      - Includes the MCP nav (`_www/mcp-nav.js`) so you can jump between MCP and widget tests.
+      - Mounts `<joe-ai-widget title="JOE AI Assistant" ai_assistant_id="...">` in a centered card.
+      - Loads `js/joe-ai.js`, which defines both `<joe-ai-chatbox>` (for in‑app use) and `<joe-ai-widget>` (for embedding).
+
+- **Shared nav link**:
+  - The shared dev nav (`_www/mcp-nav.js`) includes an “AI Widget” link:
+
+    ```html
+    <a href="/ai-widget-test.html" target="ai_widget_test_win" rel="noopener">AI Widget</a>
+    ```
 
-_joe.constructObjectFromFields()
+  - This appears on MCP test/export/prompt pages and on the AI widget test page itself.

package/server/app-config.js

@@ -31,12 +31,13 @@ var apps = function(){
             title:'JOE Platform',
             info:'This is the master Data Model Management System (DMMS) admin page. It has access to all of your schemas and datasets.',
             description:'JOE is the Json Object Editor. The Platform app has access to all your schemas and datasets.',
-            plugins:['auth.js','formBuilder.js','reportbuilder.js','callbackTester.js','memberRegistry.js','awsConnect.js','notifier.js','calendar.js','inventory.js','money.js','plugin-utils.js','chatgpt.js','chatgpt-assistants.js','chatgpt-tools.js'],
+            plugins:['auth.js','formBuilder.js','reportbuilder.js','callbackTester.js','memberRegistry.js','awsConnect.js','notifier.js','calendar.js','inventory.js','money.js','plugin-utils.js','chatgpt.js','chatgpt-assistants.js','chatgpt-tools.js','chatgpt-responses.js'],
             collections:((default_schemas.concat(['schema','group',
                 'site','page','post','layout','block','include','event',
                 'project','board','task',
                 'transaction','budget','ledger',
                 'location','device','notification',
+                /*'ai_assistant','ai_conversation','ai_response','ai_tool','ai_prompt',*/
                 'visitor','question','form','submission','session','touchpoint','member']))).sort(),
                 dashboard:[
                     JOE.Apps.Cards.appHome({cssclass:'w3 h4'}),

package/server/fields/core.js

@@ -83,22 +83,7 @@ var fields = {
             return item.instructions_format;
         }
     },
-    ai_model:{
-        type: "select",
-        display: "Ai Model",
-        values: [
-            { value: "gpt-4o", name: "GPT-4o (Fast, 128k)" },
-            { value: "gpt-4.1", name: "GPT-4.1 (Strong, 1M)" },
-            { value: "gpt-4.1-mini", name: "4.1-mini (Cheap, 1M)" },
-            { 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-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",
-      },
+
     template:{
         height:'600px',
         type:function(item){
@@ -300,6 +285,7 @@ var fields = {
         autocomplete_template:'<joe-title>${name} (.${filetype})</joe-title><joe-subtext>${info}</joe-subtext>'
 
     },
+/*    file_upload:{type:'uploader',allowmultiple:true, height:'300px',comment:'drag files here to upload', onConfirm:_joe.SERVER.Plugins.awsFileUpload,use_legacy:true},*/
     datasets:{type:'group',cols:2,
         comment:'which itemtypes(schemas) does this pertain to',values:function(){
             if(typeof(__collectionNames) != undefined){
@@ -529,7 +515,39 @@ var fields = {
             html += _joe.renderFieldListItem(item,temp,item.itemtype);
         });
         return html;
-    }}
+    }},
+    //AI Fields
+    ai_model:{
+        type: "select",
+        display: "Ai Model",
+        values: [
+            { 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)" },
+            { value:"gpt-5-nano", name: "GPT-5-nano (Fastest, light tasks)" },
+            { value: "gpt-4o", name: "GPT-4o (Fast, 128k)" },
+            { value: "gpt-4.1", name: "GPT-4.1 (Strong, 1M)" },
+            { value: "gpt-4.1-mini", name: "4.1-mini (Cheap, 1M)" },
+            { 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-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",
+      },
+    objectChat:{
+        type:'button',
+        display:'Start Chat',
+        icon:'ai_assistant',
+        onclick:function(object){
+            if (!object || !object._id) return '';
+            return `_joe.Ai.spawnChatHelper('${object._id}');`;
+        },
+        
+    }
+
 };
 
 module.exports = fields;

package/server/modules/Server.js

@@ -169,6 +169,56 @@ server.get(JOE.webconfig.joepath+'_www/mcp-schemas.html',auth,function(req,res){
     res.sendFile(path.join(JOE.joedir,'_www','mcp-schemas.html'));
 });
 
+// AI Widget test page (Responses + assistants) – auth protected
+server.get(['/ai-widget-test.html', JOE.webconfig.joepath + 'ai-widget-test.html'], auth, function(req,res){
+    var assistantId = (req.query.assistant_id || req.query.assistant || '').trim();
+    if (!assistantId && JOE && JOE.Utils && JOE.Utils.Settings) {
+        try {
+            var settingObj = JOE.Utils.Settings('DEFAULT_AI_ASSISTANT', { object: true });
+            assistantId = (settingObj && settingObj.value) || '';
+        } catch(e) {
+            console.log('[ai-widget-test] error reading DEFAULT_AI_ASSISTANT:', e && e.message);
+        }
+    }
+    var joePath = (JOE && JOE.webconfig && JOE.webconfig.joepath) || '/JsonObjectEditor/';
+    var assistantAttr = assistantId ? ' ai_assistant_id="'+assistantId.replace(/"/g,'"')+'"' : '';
+
+    res.send(`<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>JOE AI Widget Test</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body{font-family:system-ui,-apple-system,Segoe UI,Roboto,Ubuntu,Cantarell,Noto Sans,sans-serif;margin:20px;background:#f3f4f6;}
+    h1{margin-top:0;}
+    .small{font-size:13px;color:#6b7280;margin-bottom:16px;}
+    .container{max-width:480px;margin:0 auto;background:#fff;border-radius:12px;box-shadow:0 4px 14px rgba(0,0,0,0.06);padding:16px;}
+    .meta{font-size:12px;color:#6b7280;margin-bottom:8px;}
+    code{background:#e5e7eb;border-radius:4px;padding:2px 4px;font-size:12px;}
+  </style>
+</head>
+<body>
+  <div id="mcp-nav"></div>
+  <script src="${joePath}_www/mcp-nav.js"></script>
+
+  <div class="container">
+    <h1>AI Widget Test</h1>
+    <div class="small">
+      This page mounts <code>&lt;joe-ai-widget&gt;</code> and sends messages through
+      <code>/API/plugin/chatgpt/widget*</code> using the OpenAI Responses API.
+      ${assistantId ? `Using <code>DEFAULT_AI_ASSISTANT</code> (ai_assistant_id=${assistantId}).` : 'No DEFAULT_AI_ASSISTANT is set; widget will use model defaults.'}
+      You can override the assistant via <code>?assistant_id=&lt;ai_assistant _id&gt;</code>.
+    </div>
+
+    <joe-ai-widget id="widget" title="JOE AI Assistant"${assistantAttr}></joe-ai-widget>
+  </div>
+
+  <script src="${joePath}js/joe-ai.js"></script>
+</body>
+</html>`);
+});
+
 server.use(JOE.webconfig.joepath,express.static(JOE.joedir));
 
 //USER

package/server/modules/Storage.js

@@ -101,7 +101,13 @@ function Storage(specs){
             try{
                 if(!data.joeUpdated){ data.joeUpdated = new Date().toISOString(); }
                 if(!data.created){
-                    var cachedBefore = (data && data._id && JOE && JOE.Cache && JOE.Cache.findByID) ? JOE.Cache.findByID(collection,data._id) : null;
+                    var cachedBefore = null;
+                    // Only use Cache.findByID when _id is a string; ObjectId instances can cause internal split() errors.
+                    if (data && data._id && typeof data._id === 'string' && JOE && JOE.Cache && JOE.Cache.findByID){
+                        try {
+                            cachedBefore = JOE.Cache.findByID(collection, data._id);
+                        } catch(__e){ cachedBefore = null; }
+                    }
                     if(!cachedBefore){ data.created = new Date().toISOString(); }
                 }
             }catch(_e){}

package/server/modules/Utils.js

@@ -74,7 +74,8 @@ var utils = function(){
                     module:"\x1b[33m",
                     white:"\x1b[37m",
                     black:'\x1b[30m',
-                    gray:'\x1b[90m'
+                    gray:'\x1b[90m',
+                    teal:'\x1b[36m'
                 };
                 var messagestring = '';
                 styles.map(function(i){

package/server/plugins/awsConnect.js

@@ -1,8 +1,8 @@
 function AWSConnect(){
     var self = this;
 this.default = function(data,req,res){
-    // Load the AWS SDK for Node.js
-var AWS = require('aws-sdk');
+    // AWS SDK v3 (modular)
+const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');
 var settings_config = tryEval(JOE.Cache.settings.AWS_S3CONFIG)||{};
 var config = $c.merge(settings_config);
 
@@ -10,10 +10,18 @@ var filename = data.filename || req.params.filename||cuid();
 var directory = data.directory|| req.params.directory || 'uploads';
 var Key = data.Key || directory+'/'+filename;
 
-// Set your region for future requests.
-AWS.config.update(config);
+// Create S3 client with provided config (region/credentials)
+const s3 = new S3Client({
+    region: config.region,
+    credentials: (config.accessKeyId && config.secretAccessKey) ? {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+        sessionToken: config.sessionToken
+    } : undefined
+});
 
-var ACL = data.ACL || 'public-read';
+// Default to public-read unless explicitly overridden; allows legacy behavior to keep working
+var ACL = (data.hasOwnProperty('ACL') ? data.ACL : 'public-read');
 var Bucket = JOE.Cache.settings.AWS_BUCKETNAME;
 var file = data.file || 'body';
 // Create a bucket using bound parameters and put something in it.
@@ -25,14 +33,14 @@ var s3Params = {
 
 if(data.base64){
     //var buf = new Buffer(data.base64.replace(/^data:image\/\w+;base64,/, ""),'base64');
-    var buf = new Buffer(data.base64.replace(/^data:[a-zA-Z0-9\_\-]*\/[a-zA-Z0-9\_\-]*;base64,/, ""),'base64');
+    var buf = Buffer.from(data.base64.replace(/^data:[a-zA-Z0-9\_\-]*\/[a-zA-Z0-9\_\-]*;base64,/, ""),'base64');
     s3Params.Body = buf;
     s3Params.ContentEncoding = 'base64';
-    s3Params.ContentType = data.extension || 'image/jpeg';
+    // Prefer explicit contentType; fall back to extension or a safe default
+    s3Params.ContentType = data.contentType || data.extension || 'application/octet-stream';
     
 }
 
-var s3bucket = new AWS.S3(s3Params);
 var payload = {
     params:s3Params,
     config:config,
@@ -45,19 +53,42 @@ var response = {
     Key:Key,
     bucket:Bucket
 }
-    s3Params.ACL = ACL || 'public-read';
-    s3bucket.putObject(s3Params, function(err, data) {
-        response.data = data;
-        response.error = err;
-        res.send(response);
+    // Early validation
+    if(!Bucket){
+        return res.status(400).send({ error:'AWS bucket is not configured (settings.AWS_BUCKETNAME).' });
+    }
+    if(!config || !config.region){
+        return res.status(400).send({ error:'AWS S3 region is missing. Set settings.AWS_S3CONFIG.region.' });
+    }
+
+    // Only include ACL if requested (string and not empty)
+    if(ACL){
+        s3Params.ACL = ACL;
+    }
 
-        if (err) {
-        console.log("Error uploading data: ", err);
-        } else {
-        console.log("Successfully uploaded data to "+Key);
-        }
-        return;
-    });
+    s3.send(new PutObjectCommand(s3Params))
+        .then(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;
+            res.status(200).send(response);
+            console.log("Successfully uploaded data to "+Key);
+        })
+        .catch(function(err){
+            var code = (err && (err.Code || err.name)) || 'UploadError';
+            var message = (err && (err.message || String(err))) || 'Upload failed';
+            // Clear, actionable error when ACLs are disabled on bucket
+            if(code === 'AccessControlListNotSupported'){
+                return res.status(400).send({ 
+                    error: 'Bucket has ACLs disabled (Object Ownership enforced). Remove ACL or switch to presigned/proxy access.', 
+                    code: code 
+                });
+            }
+            console.log("Error uploading data: ", err);
+            res.status(500).send({ error: message, code: code });
+        });
     return {use_callback:true};
 
     },

package/server/plugins/chatgpt-assistants.js

@@ -1,6 +1,7 @@
-
-const { run } = require("googleapis/build/src/apis/run");
+const savedArrayDelete = Array.prototype.delete;
+delete Array.prototype.delete;
 const OpenAI = require("openai");
+if (savedArrayDelete) Array.prototype.delete = savedArrayDelete;
 
 function ChatGPTAssistants() {
   const self = this;
@@ -67,7 +68,6 @@ function ChatGPTAssistants() {
   }
   this.syncAssistantToOpenAI = async function(data, req, res) {
     const openai = newClient();
-  
     try {
       coloredLog("🔄 Starting syncAssistantToOpenAI");
   

package/server/plugins/chatgpt-responses.js

@@ -0,0 +1,45 @@
+const OpenAI = require("openai");
+
+function ChatGPTResponses() {
+	const self = this;
+
+	function log(prefix, message, data) {
+		const p = JOE.Utils.color('[chatgpt-responses]', 'plugin', false);
+		console.log(p, prefix, message || '', (data !== undefined ? data : ''));
+	}
+
+	this.default = function (data, req, res) {
+		try {
+			return {
+				success: true,
+				message: 'chatgpt-responses proxy plugin ready',
+				params: req.params,
+				query: req.query,
+				body: req.body
+			};
+		} catch (e) {
+			return { errors: 'plugin error: ' + e, failedat: 'plugin' };
+		}
+	};
+
+	// Thin proxy to chatgpt.autofill to avoid duplication
+	this.autofill = async function (data, req, res) {
+		try {
+			const base = JOE.Apps && JOE.Apps.plugins && JOE.Apps.plugins['chatgpt'];
+			if (!base || !base.autofill) {
+				return { success: false, error: 'chatgpt.autofill not available' };
+			}
+			const result = await base.autofill(data, req, res);
+			return result;
+		} catch (e) {
+			log('error', e && e.message);
+			return { success: false, error: e && e.message || 'Unknown error' };
+		}
+	};
+
+	return self;
+}
+
+module.exports = new ChatGPTResponses();
+
+