json-object-editor 0.10.625 → 0.10.632

package/package.json

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

package/readme.md

@@ -660,4 +660,11 @@ To help you develop and debug the widget + plugin in your instance, JOE exposes
     <a href="/ai-widget-test.html" target="ai_widget_test_win" rel="noopener">AI Widget</a>
     ```
 
-  - This appears on MCP test/export/prompt pages and on the AI widget test page itself.
+  - This appears on MCP test/export/prompt pages and on the AI widget test page itself.
+
+### AI / Widget Changelog (current work – `0.10.632`)
+
+- Added a Responses‑based tool runner for `<joe-ai-widget>` that wires `ai_assistant.tools` into MCP functions via `chatgpt.runWithTools`.
+- Enhanced widget UX: assistant/user bubble theming (using `assistant_color` and user `color`), inline “tools used this turn” meta messages, and markdown rendering for assistant replies.
+- Expanded the AI widget test page with an assistant picker, live tool JSON viewer, a clickable conversation history list (resume existing `ai_widget_conversation` threads), and safer user handling (widget conversations now store user id/name/color explicitly and OAuth token‑exchange errors from Google are surfaced clearly during login).
+- Added field-level AI autofill support: schemas can declare `ai` config on a field (e.g. `{ name:'ai_summary', type:'rendering', ai:{ prompt:'Summarize the project in a few sentences.' } }`), which renders an inline “AI” button that calls `_joe.Ai.populateField('ai_summary')` and posts to `/API/plugin/chatgpt/autofill` to compute a JSON `patch` and update the UI (with confirmation before overwriting non-empty values).

package/server/apps/aihub.js

@@ -0,0 +1,97 @@
+var App = function () {
+
+    this.title = 'AIHub';
+    this.description = 'Central hub for managing AI assistants, prompts, tools, conversations, and widget chats in JOE.';
+
+    // Core AI-related schemas in JOE
+    this.collections = [
+        'ai_assistant',
+        'ai_prompt',
+        'ai_tool',
+        'ai_response',
+        'ai_conversation',
+        'ai_widget_conversation'
+    ].concat(JOE.webconfig.default_schemas);
+
+    this.dashboard = [
+        // Standard app home: shows AIHub schemas plus default schemas
+        JOE.Apps.Cards.appHome({ cssclass: 'w2 h3' }),
+
+        // Small MCP test portal card
+        {
+            type: 'Card',
+            config: {
+                title: 'MCP Test Portal',
+                left: 0,
+                top: 3,
+                cssclass: 'w2 h1',
+                content: function () {
+                    return '' +
+                        '<div class="spaced">' +
+                          '<div><b>MCP Tools & Tests</b></div>' +
+                          '<ul style="margin:6px 0 0 16px; padding:0; list-style:disc;">' +
+                            '<li><a href="/mcp-test.html" target="mcp_test_win" rel="noopener">MCP Test</a></li>' +
+                            '<li><a href="/mcp-export.html" target="mcp_export_win" rel="noopener">MCP Export</a></li>' +
+                            '<li><a href="/mcp-schemas.html" target="mcp_schemas_win" rel="noopener">Schemas</a></li>' +
+                            '<li><a href="/mcp-prompt.html" target="mcp_prompt_win" rel="noopener">MCP Prompt</a></li>' +
+                            '<li><a href="/ai-widget-test.html" target="ai_widget_test_win">AI Widget</a></li>'+
+                          '</ul>' +
+                        '</div>';
+                }
+            }
+        },
+
+        // Cap card with an embedded joe-ai-widget that fills the panel
+        {
+            type: 'Card',
+            config: {
+                title: 'AIHub Chat',
+                left: 2,
+                top: 0,
+                cssclass: 'w4 h4',
+                content: function () {
+                    return '' +
+                        '<div style="width:100%;height:100%;display:flex;flex-direction:column;">' +
+                          '<joe-ai-assistant-picker for_widget="aihub_widget"></joe-ai-assistant-picker>' +
+                          '<joe-ai-widget ' +
+                            'id="aihub_widget" ' +
+                            'title="AIHub Assistant" ' +
+                            'source="aihub_card" ' +
+                            'user_id="' + ((_joe && _joe.User && _joe.User._id) || '') + '" ' +
+                            'style="flex:1 1 auto;width:100%;height:100%;">' +
+                          '</joe-ai-widget>' +
+                        '</div>';
+                }
+            }
+        },
+
+        // Widget conversations list (replaces Recently Updated AI Items card for now)
+        {
+            type: 'Card',
+            config: {
+                title: 'Widget Conversations',
+                left: 6,
+                top: 1,
+                cssclass: 'w2 h3',
+                content: function () {
+                    return '' +
+                        '<div style="width:100%;height:100%;display:flex;flex-direction:column;">' +
+                          '<joe-ai-conversation-list ' +
+                            'for_widget="aihub_widget" ' +
+                            'source="aihub_card">' +
+                          '</joe-ai-conversation-list>' +
+                        '</div>';
+                }
+            }
+        },
+
+        // Platform/system stats in the context of AIHub
+        JOE.Apps.Cards.systemStats({ top: 0, left: 6 })
+    ];
+
+    return this;
+};
+
+module.exports = new App();
+
+

package/server/fields/core.js

@@ -546,7 +546,10 @@ var fields = {
             return `_joe.Ai.spawnChatHelper('${object._id}');`;
         },
         
-    }
+    },
+    listConversations:{display:'Ai Conversations', type:"content",reloadable:true,run:function(obj){
+        return _joe.schemas.ai_conversation.methods.listConversations(obj,true);
+    }},
 
 };
 

package/server/modules/MCP.js

@@ -7,12 +7,21 @@
  */
 
 const MCP = {};
-const { Storage, Schemas } = global.JOE; // Adjust as needed based on how your modules are wired
 
 // Internal helpers
+function getStorage() {
+  return (global.JOE && global.JOE.Storage) || null;
+}
+
+function getSchemas() {
+  return (global.JOE && global.JOE.Schemas) || null;
+}
+
 function loadFromStorage(collection, query) {
   return new Promise((resolve, reject) => {
     try {
+      const Storage = getStorage();
+      if (!Storage) return reject(new Error('Storage module not initialized'));
       Storage.load(collection, query || {}, function(err, results){
         if (err) return reject(err);
         resolve(results || []);
@@ -38,6 +47,60 @@ function sanitizeItems(items) {
   }
 }
 
+// Resolve simple dotted paths against an object, including arrays.
+// Example: getPathValues(recipe, "ingredients.id") → ["ing1","ing2",...]
+function getPathValues(root, path) {
+  if (!root || !path) return [];
+  const parts = String(path).split('.');
+  let current = [root];
+  for (let i = 0; i < parts.length; i++) {
+    const key = parts[i];
+    const next = [];
+    for (let j = 0; j < current.length; j++) {
+      const val = current[j];
+      if (val == null) continue;
+      if (Array.isArray(val)) {
+        val.forEach(function (item) {
+          if (item && Object.prototype.hasOwnProperty.call(item, key)) {
+            next.push(item[key]);
+          }
+        });
+      } else if (Object.prototype.hasOwnProperty.call(val, key)) {
+        next.push(val[key]);
+      }
+    }
+    current = next;
+    if (!current.length) break;
+  }
+  // Flatten one level in case the last hop produced arrays
+  const out = [];
+  current.forEach(function (v) {
+    if (Array.isArray(v)) {
+      v.forEach(function (x) { if (x != null) out.push(x); });
+    } else if (v != null) {
+      out.push(v);
+    }
+  });
+  return out;
+}
+
+// Best-effort helper to get a normalized schema summary for a given name.
+// Prefers the precomputed `Schemas.summary[name]` map, but falls back to
+// `Schemas.schema[name].summary` when the summary map has not been generated
+// or that particular schema has not yet been merged in.
+function getSchemaSummary(name) {
+  if (!name) return null;
+  const Schemas = getSchemas();
+  if (!Schemas) return null;
+  if (Schemas.summary && Schemas.summary[name]) {
+    return Schemas.summary[name];
+  }
+  if (Schemas.schema && Schemas.schema[name] && Schemas.schema[name].summary) {
+    return Schemas.schema[name].summary;
+  }
+  return null;
+}
+
 function getComparable(val){
   if (val == null) return null;
   // Date-like
@@ -84,6 +147,7 @@ MCP.tools = {
 
   // List all schema names in the system
   listSchemas: async (_params, _ctx) => {
+    var Schemas = getSchemas();
     const list = (Schemas && (
       (Schemas.schemaList && Schemas.schemaList.length && Schemas.schemaList) ||
       (Schemas.schema && Object.keys(Schemas.schema))
@@ -146,6 +210,156 @@ MCP.tools = {
     return sanitizeItems(obj)[0];
   },
 
+  /**
+   * understandObject
+   *
+   * High-level helper for agents: given an _id (and optional itemtype),
+   * returns a rich payload combining:
+   *   - object:     the raw object (ids intact)
+   *   - flattened:  the same object flattened to a limited depth
+   *   - schemas:    a map of schema summaries for the main itemtype and any
+   *                 referenced itemtypes (keyed by schema name)
+   *   - related:    an array of referenced objects discovered via outbound
+   *                 relationships in the schema summary.
+   *
+   * When `slim` is false (default), each related entry includes both `object`
+   * and `flattened`. When `slim` is true, only the main object is flattened
+   * and related entries are reduced to slim references:
+   *   { field, _id, itemtype, object: { _id, itemtype, name, info } }
+   *
+   * Agents should prefer this tool when they need to understand or work with
+   * an object by id, instead of issuing many individual getObject / getSchema
+   * calls. The original object always keeps its reference ids; expanded views
+   * live under `flattened` and `related[*]`.
+   */
+  understandObject: async ({ _id, itemtype, schema, depth = 2, slim = false } = {}, _ctx) => {
+    if (!_id) throw new Error("Missing required param '_id'");
+    itemtype = itemtype || schema;
+
+    // Base object (sanitized) without flattening
+    const base = await MCP.tools.getObject({ _id, itemtype, flatten: false }, _ctx);
+    const mainType = base.itemtype || itemtype || null;
+
+    const result = {
+      _id: base._id,
+      itemtype: mainType,
+      object: base,
+      flattened: null,
+      schemas: {},
+      related: [],
+      // Deduped lookups for global reference types
+      tags: {},
+      statuses: {},
+      slim: !!slim
+    };
+
+    // Main schema summary
+    const mainSummary = getSchemaSummary(mainType);
+    if (mainType && mainSummary) {
+      result.schemas[mainType] = mainSummary;
+    }
+
+    // Flattened view of the main object (depth-limited)
+    if (JOE && JOE.Utils && JOE.Utils.flattenObject) {
+      try {
+        const flat = JOE.Utils.flattenObject(base._id, { recursive: true, depth });
+        result.flattened = sanitizeItems(flat)[0];
+      } catch (_e) {
+        result.flattened = null;
+      }
+    }
+
+    const seenSchemas = new Set(Object.keys(result.schemas || {}));
+    function addSchemaIfPresent(name) {
+      if (!name || seenSchemas.has(name)) return;
+      const sum = getSchemaSummary(name);
+      if (sum) {
+        result.schemas[name] = sum;
+        seenSchemas.add(name);
+      }
+    }
+
+    // Discover outbound relationships from schema summary
+    const schemaSummary = mainType && getSchemaSummary(mainType);
+    const outbound = (schemaSummary &&
+      schemaSummary.relationships &&
+      Array.isArray(schemaSummary.relationships.outbound))
+      ? schemaSummary.relationships.outbound
+      : [];
+
+    for (let i = 0; i < outbound.length; i++) {
+      const rel = outbound[i] || {};
+      const field = rel.field;
+      const targetSchema = rel.targetSchema;
+      if (!field || !targetSchema) continue;
+
+      // Support nested paths like "ingredients.id" coming from objectList fields.
+      const vals = getPathValues(base, field);
+      if (!vals || !vals.length) continue;
+
+      const ids = Array.isArray(vals) ? vals : [vals];
+      for (let j = 0; j < ids.length; j++) {
+        const rid = ids[j];
+        if (!rid) continue;
+        let robj = null;
+        try {
+          robj = await MCP.tools.getObject({ _id: rid, itemtype: targetSchema, flatten: false }, _ctx);
+        } catch (_e) {
+          continue;
+        }
+        if (!robj) continue;
+
+        const rType = robj.itemtype || targetSchema;
+        // Global reference types (tag/status) go into top-level lookup maps
+        if (rType === 'tag' || rType === 'status') {
+          const mapName = (rType === 'tag') ? 'tags' : 'statuses';
+          if (!result[mapName][robj._id]) {
+            result[mapName][robj._id] = {
+              _id: robj._id,
+              itemtype: rType,
+              name: robj.name || robj.label || robj.info || ''
+            };
+          }
+        } else {
+          if (slim) {
+            const slimObj = toSlim(robj);
+            result.related.push({
+              field,
+              _id: slimObj._id,
+              itemtype: slimObj.itemtype || rType,
+              object: {
+                _id: slimObj._id,
+                itemtype: slimObj.itemtype || rType,
+                name: slimObj.name,
+                info: slimObj.info
+              }
+            });
+          } else {
+            let rflat = null;
+            if (JOE && JOE.Utils && JOE.Utils.flattenObject) {
+              try {
+                const f = JOE.Utils.flattenObject(robj._id, { recursive: true, depth: Math.max(1, depth - 1) });
+                rflat = sanitizeItems(f)[0];
+              } catch (_e) {
+                rflat = null;
+              }
+            }
+            result.related.push({
+              field,
+              _id: robj._id,
+              itemtype: rType,
+              object: robj,
+              flattened: rflat
+            });
+          }
+        }
+        addSchemaIfPresent(rType || targetSchema);
+      }
+    }
+
+    return result;
+  },
+
   /* Deprecated: use unified 'search' instead
   getObjectsByIds: async () => { throw new Error('Use search with ids instead'); },
   queryObjects: async () => { throw new Error('Use search instead'); },
@@ -249,6 +463,8 @@ MCP.tools = {
 
   // Save an object via Storage (respects events/history)
   saveObject: async ({ object }, ctx = {}) => {
+    const Storage = getStorage();
+    if (!Storage) throw new Error('Storage module not initialized');
     if (!object || !object.itemtype) throw new Error("'object' with 'itemtype' is required");
     const user = (ctx.req && ctx.req.User) ? ctx.req.User : { name: 'anonymous' };
     // Ensure server-side update timestamp parity with /API/save
@@ -270,6 +486,8 @@ MCP.tools = {
 
   // Batch save with bounded concurrency; preserves per-item history/events
   saveObjects: async ({ objects, stopOnError = false, concurrency = 5 } = {}, ctx = {}) => {
+    const Storage = getStorage();
+    if (!Storage) throw new Error('Storage module not initialized');
     if (!Array.isArray(objects) || objects.length === 0) {
       throw new Error("'objects' (non-empty array) is required");
     }
@@ -325,6 +543,7 @@ MCP.tools = {
 
   // Hydration: surface core fields (from file), all schemas, statuses, and tags (no params)
   hydrate: async (_params, _ctx) => {
+    var Schemas = getSchemas();
     let coreDef = (JOE && JOE.Fields && JOE.Fields['core']) || null;
     if (!coreDef) {
       try { coreDef = require(__dirname + '/../fields/core.js'); } catch (_e) { coreDef = {}; }
@@ -387,7 +606,8 @@ MCP.descriptions = {
   saveObject: "Create/update an object; triggers events/history.",
   saveObjects: "Batch save objects with bounded concurrency; per-item history/events preserved.",
   hydrate: "Loads and merges the full JOE context, including core and organization-specific schemas, relationships, universal fields (tags and statuses), and datasets. Returns a single unified object describing the active environment for use by agents, UIs, and plugins.",
-  listApps: "List app definitions (title, description, collections, plugins)."
+  listApps: "List app definitions (title, description, collections, plugins).",
+  understandObject: "High-level helper: given an _id (and optional itemtype), returns { object, flattened, schemas, related[] } combining the main object, its schema summary, and referenced objects plus their schemas. Prefer this when you need to understand or reason about an object by id instead of issuing many separate getObject/getSchema calls."
 };
 
 MCP.params = {
@@ -440,6 +660,17 @@ MCP.params = {
     },
     required: []
   },
+  understandObject: {
+    type: "object",
+    properties: {
+      _id: { type: "string" },
+      itemtype: { type: "string" },
+      schema: { type: "string" },
+      depth: { type: "integer" },
+      slim: { type: "boolean" }
+    },
+    required: ["_id"]
+  },
   fuzzySearch: {
     type: "object",
     properties: {

package/server/modules/Server.js

@@ -171,52 +171,7 @@ server.get(JOE.webconfig.joepath+'_www/mcp-schemas.html',auth,function(req,res){
 
 // 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>`);
+    res.sendFile(path.join(JOE.joedir,'_www','ai-widget-test.html'));
 });
 
 server.use(JOE.webconfig.joepath,express.static(JOE.joedir));

package/server/plugins/auth.js

@@ -22,50 +22,46 @@ function Auth(){
     };
 
     this.login = async function(data,req,res){
-        const got = await import('got');
-        //make post request
+        // Use got to exchange the Google authorization_code for tokens.
+        // We POST form-encoded params to the current Google OAuth token endpoint.
+        const gotMod = await import('got');
+        const got = gotMod.default || gotMod;
+
         var originalUrl = data.state||'';
         console.log(originalUrl);
 
-        var options = { 
+        const tokenUrl = 'https://oauth2.googleapis.com/token';
+        const options = { 
             method: 'POST',
-            url: 'https://www.googleapis.com/oauth2/v4/token',
-            searchParams: {
+            // Google expects application/x-www-form-urlencoded body, not querystring.
+            form: {
                 grant_type: 'authorization_code',
                 code: data.code,
                 redirect_uri: `${JOE.webconfig.authorization.host}/API/plugin/auth/login`,
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'client_id':JOE.webconfig.authorization.client_id,
-                'client_secret':JOE.webconfig.authorization.client_secret
+                client_id: JOE.webconfig.authorization.client_id,
+                client_secret: JOE.webconfig.authorization.client_secret
             },
-            headers: 
-            {
+            headers: {
                 'cache-control': 'no-cache',
-                Authorization: JOE.webconfig.authorization.header,
-                Accept: 'application/json',
-
+                Accept: 'application/json'
             },
             responseType: 'json',
             https: {
               rejectUnauthorized: false
             }
-            // rejectUnauthorized:false,
-            // json: true 
         };
 
-       // request(options, function (error, response, body) {
-        got.default(options)
-        .catch(error => {
-            res.send(error);
-        })
+        got(tokenUrl, options)
         .then(response => {  
-            const body = response.body;
+            const body = response.body || {};
             // if (error){
             //     res.send(error);
             //     return;
             // }
             if (body.error){
-                res.send(body.error);
+                // Bubble up Google's error payload so it's easier to diagnose
+                console.error('[auth.login] Google token error payload:', body);
+                res.status(400).send(body);
                 return;
             }
             //res.send(body);
@@ -91,17 +87,25 @@ function Auth(){
                 res.redirect(finalUrl);
                 return;
             }
-        //redirect to home or gotoUrl
+            //redirect to home or gotoUrl
             res.redirect(originalUrl || `/JOE/${User.apps[0]}`);
-            //res.send(body);
-            
-
-            
+        })
+        .catch(error => {
+            // Log structured info so we can see status + body from Google
+            const status = error.response && error.response.statusCode;
+            const body = error.response && error.response.body;
+            console.error('[auth.login] HTTPError from Google token endpoint:', {
+                status,
+                body,
+                message: error.message
+            });
+            res.status(status || 500).send(body || {
+                error: 'oauth_token_error',
+                message: error.message
+            });
         });
 
-     
-        //return(data);
-        return({use_callback:true})
+        return({use_callback:true});
     }
     this.html = function(data,req,res){