json-object-editor 0.10.660 → 0.10.662

package/server/fields/core.js

@@ -170,7 +170,7 @@ var fields = {
             return status.color||'';
         }
     },
-    tags:{type:'group',icon:'tag',hidden:function(obj){
+    tags:{type:'group',icon:'tag',reloadable:true,hidden:function(obj){
         let tags = _joe.Data.tag.filter(function(tag){
             return !(tag.datasets.indexOf(item.itemtype) == -1);
         });
@@ -542,6 +542,53 @@ var fields = {
             4.1-nano is best for lightweight classification or routing logic where speed and cost matter more than depth.`,
         default: "gpt-5-mini",
       },
+    mcp_enabled:{
+        type:'boolean',
+        display:'Enable MCP tools',
+        default:false,
+        comment:'When true, this surface may call JOE MCP tools (read-only by default unless toolset/custom overrides it).'
+    },
+    mcp_toolset:{
+        type:'select',
+        display:'MCP Toolset',
+        values:[
+            {value:'read-only',name:'Read-only (safe defaults)'},
+            {value:'minimal',name:'Minimal (small safe subset)'},
+            {value:'all',name:'All MCP tools'},
+            {value:'custom',name:'Custom selection'}
+        ],
+        default:'read-only',
+        rerender:'mcp_selected_tools',
+        comment:'Choose which MCP toolset to expose when MCP tools are enabled.'
+    },
+    mcp_selected_tools:{
+        type:'select',
+        display:'Custom MCP tools (names)',
+        isArray:true,
+        allowMultiple:true,
+        values:function(doc){
+            try{
+                return (window._joe && _joe.Ai && Array.isArray(_joe.Ai.mcpToolNames)) ? _joe.Ai.mcpToolNames : [];
+            }catch(e){
+                return [];
+            }
+        },
+        hidden:function(doc){
+            return !doc || doc.mcp_toolset !== 'custom';
+        },
+        comment:'Multi-select from MCP manifest tool names. Only used when MCP Toolset = custom.'
+    },
+    mcp_instructions_mode:{
+        type:'select',
+        display:'MCP Instructions Mode',
+        values:[
+            {value:'auto',name:'Auto (short per-tool instructions)'},
+            {value:'full',name:'Full MCP instructions block'},
+            {value:'none',name:'No MCP instructions (tools only)'}
+        ],
+        default:'auto',
+        comment:'Controls whether and how MCP tool instructions are appended to system text.'
+    },
     objectChat:{
         type:'button',
         display:'Start Chat',

package/server/modules/MCP.js

@@ -1019,6 +1019,10 @@ MCP.buildToolInstructions = function(toolNames, mode){
   if (m === 'none') { return ''; }
 
   const lines = [];
+  // Visual section break so humans (and logs/debug views) can easily
+  // spot where the MCP tool list begins inside a larger system prompt.
+  // This is purely presentational and does not affect tool behavior.
+  lines.push('----- JOE MCP tools -----');
   lines.push('You can call the following JOE MCP tools when helpful:');
   toolNames.forEach(function(name){
     const desc = MCP.descriptions && MCP.descriptions[name] || '';

package/server/modules/Sites.js

@@ -48,6 +48,9 @@ function getInclude(req,res,next){
         case 'css':
             res.set('Content-Type', 'text/css');
             break;
+        case 'json':
+            res.set('Content-Type', 'application/json');
+            break;
     }
     res.send(content);
 }
@@ -536,8 +539,31 @@ var routeWithoutSlash = route.startsWith('/') ? route.slice(1) : route;
                 page.content = Editor.wrap(page.content,'jpe-content',{name:'page content'})
             }
 
-            var template = layout.template.replace('${this.PAGE.content}',content.PAGE.content);
-            var html = fillTemplate(template,content);
+            // First, process page content with fillTemplate to resolve variables like ${INCLUDES}, ${this.PAGE.name}, etc.
+            // This is needed because these variables are INSIDE the page content
+            var pageContent = content.PAGE.content || '';
+            pageContent = pageContent.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            
+            // Preserve newlines before fillTemplate strips them
+            // Replace newlines with a temporary marker that we'll restore later
+            var newlineMarker = '__JOE_NEWLINE__' + Date.now() + '__';
+            var pageContentWithMarkers = pageContent.replace(/\n/g, newlineMarker);
+            
+            // Process page content with fillTemplate to resolve template variables
+            var processedPageContent = fillTemplate(pageContentWithMarkers, content);
+            
+            // Restore newlines after fillTemplate processing
+            processedPageContent = processedPageContent.replace(new RegExp(newlineMarker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), '\n');
+            
+            // Use a placeholder for ${this.PAGE.content} in layout template
+            var placeholder = '__JOE_PAGE_CONTENT_PLACEHOLDER__' + Date.now() + '__';
+            var template = layout.template.replace(/\$\{this\.PAGE\.content\}/g, placeholder);
+            
+            // Process layout template with fillTemplate (which will strip newlines from layout, but our placeholder remains)
+            var html = fillTemplate(template, content);
+            
+            // Replace placeholder with processed page content (which has newlines preserved)
+            html = html.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), processedPageContent);
             if(editor){
                 html = html.replace('</head>',Editor.styles+'</head>')
                 .replace('</body>',Editor.gui(layout)+Editor.gui(page)+Editor.menu

package/server/plugins/chatgpt.js

@@ -19,7 +19,28 @@ function ChatGPT() {
     var self = this;
     this.async ={};
     function coloredLog(message){
-        console.log(JOE.Utils.color('[chatgpt]', 'plugin', false), message);
+        try{
+            // Only emit verbose plugin logs in non‑production environments.
+            // This keeps consoles clean in production while preserving rich
+            // traces (assistant resolution, MCP config, systemText) during
+            // local/dev debugging.
+            var env = null;
+            if (typeof JOE !== 'undefined' && JOE && JOE.webconfig && JOE.webconfig.env){
+                env = JOE.webconfig.env;
+            } else if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV){
+                env = process.env.NODE_ENV;
+            }
+            if (env && env.toLowerCase() === 'production'){
+                return;
+            }
+            console.log(JOE.Utils.color('[chatgpt]', 'plugin', false), message);
+        }catch(_e){
+            // If anything goes wrong determining env, default to logging so
+            // that development debugging is not silently broken.
+            try{
+                console.log('[chatgpt]', message);
+            }catch(__e){}
+        }
     }
     //xx -setup and send a test prompt to chatgpt
     //xx get the api key from joe settings
@@ -58,6 +79,23 @@ function ChatGPT() {
         const summary = JOE.Schemas && JOE.Schemas.summary && JOE.Schemas.summary[name];
         return { full, summary };
     }
+    function buildMcpToolsFromConfig(cfg) {
+        if (!cfg || !cfg.mcp_enabled) {
+            return { tools: null, names: [] };
+        }
+        try {
+            const names = MCP.getToolNamesForToolset(
+                cfg.mcp_toolset || 'read-only',
+                Array.isArray(cfg.mcp_selected_tools) ? cfg.mcp_selected_tools : null
+            );
+            const defs = MCP.getToolDefinitions(names);
+            return { tools: defs, names: names };
+        } catch (e) {
+            console.warn('[chatgpt] buildMcpToolsFromConfig failed', e);
+            return { tools: null, names: [] };
+        }
+    }
+
     /**
      * callMCPTool
      *
@@ -270,29 +308,32 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
         const attachmentsMode = opts.attachments_mode || null;
         const openaiFileIds = opts.openai_file_ids || null;
 
-        // Normalize tools: in many schemas tools may be stored as a JSON string;
-        // here we accept either an array or a JSON-stringified array.
-        let tools = null;
+        // Debug/trace: log the effective system instructions going into this
+        // Responses+tools call. This helps verify assistant + MCP instructions
+        // wiring across prompts, assists, autofill, and widget chat.
+        try{
+            coloredLog('runWithTools systemText:\n' + systemText);
+        }catch(_e){}
+
+        // Normalize tools: manual assistant.tools plus optional MCP tools
+        let manualTools = null;
         if (assistant && assistant.tools) {
             if (Array.isArray(assistant.tools)) {
-                tools = assistant.tools;
+                manualTools = assistant.tools;
             } else if (typeof assistant.tools === 'string') {
                 try {
                     const parsed = JSON.parse(assistant.tools);
                     if (Array.isArray(parsed)) {
-                        tools = parsed;
+                        manualTools = parsed;
                     }
                 } catch (e) {
                     console.error('[chatgpt] Failed to parse assistant.tools JSON', e);
                 }
             }
         }
-        // Normalize tool definitions for the Responses API. The assistant UI
-        // uses the Assistants-style shape ({ type:'function', function:{...} }),
-        // but Responses expects the name/description/parameters at the top level:
-        //   { type:'function', name:'x', description:'...', parameters:{...} }
-        if (Array.isArray(tools)) {
-            tools = tools.map(function (t) {
+        // Flatten any Assistants-style function definitions
+        if (Array.isArray(manualTools)) {
+            manualTools = manualTools.map(function (t) {
                 if (t && t.type === 'function' && t.function && !t.name) {
                     const fn = t.function || {};
                     return {
@@ -306,6 +347,26 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
             });
         }
 
+        // Merge manual tools with MCP tools (manual wins on name collisions).
+        let tools = null;
+        const mergedByName = {};
+        const mcp = buildMcpToolsFromConfig(assistant || {});
+        const mcpTools = Array.isArray(mcp.tools) ? mcp.tools : null;
+
+        if (Array.isArray(manualTools) || Array.isArray(mcpTools)) {
+            tools = [];
+            (manualTools || []).forEach(function(t){
+                if (!t) { return; }
+                if (t.name) { mergedByName[t.name] = true; }
+                tools.push(t);
+            });
+            (mcpTools || []).forEach(function(t){
+                if (!t || !t.name) { return; }
+                if (mergedByName[t.name]) { return; }
+                tools.push(t);
+            });
+        }
+
         // No tools configured – do a simple single Responses call.
         if (!tools) {
             const resp = await openai.responses.create({
@@ -1096,6 +1157,24 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             return { error: "Prompt not found." };
         }
 
+        // If this prompt run is associated with a JOE ai_assistant, log which
+        // assistant is being used so we can debug "which agent handled this?"
+        try{
+            const aiAssistantId = data.ai_assistant_id || null;
+            if (aiAssistantId) {
+                let asst = null;
+                try{
+                    // Prefer explicit ai_assistant schema lookup, then fallback
+                    // to a generic get in case datasets are flattened.
+                    asst = $J.get(aiAssistantId,'ai_assistant') || $J.get(aiAssistantId);
+                }catch(_e){}
+                const label = asst && (asst.name || asst.title || asst.info || asst._id) || aiAssistantId;
+                coloredLog('[prompt] executeJOEAiPrompt using ai_assistant: '
+                    + label + ' [' + aiAssistantId + ']'
+                    + ' for prompt: ' + (prompt.name || prompt._id));
+            }
+        }catch(_e){}
+
         let instructions = prompt.instructions || "";
         let finalInstructions=instructions;
         let finalInput='';
@@ -1705,17 +1784,59 @@ this.executeJOEAiPrompt = async function(data, req, res) {
                 }
             }
 
-            const assistantId = body.assistant_id || convo.assistant_id || null;
-            // NOTE: assistantId here is the OpenAI assistant_id, not the JOE cuid.
-            // We do NOT pass assistant_id to the Responses API (it is not supported in the
-            // version we are using); instead we look up the JOE ai_assistant by assistant_id
-            // and inject its configuration (model, instructions, tools) into the request.
-            var assistantObj = null;
-            if (assistantId && JOE && JOE.Data && Array.isArray(JOE.Data.ai_assistant)) {
-                assistantObj = JOE.Data.ai_assistant.find(function (a) {
-                    return a && a.assistant_id === assistantId;
+        // Resolve the JOE ai_assistant driving this conversation. We support
+        // both the modern flow (ai_assistant_id / convo.assistant, which are
+        // JOE cuid references) and the legacy OpenAI Assistants flow
+        // (assistant_id / convo.assistant_id, which are OpenAI ids).
+        var assistantObj = null;
+        var joeAssistantId = body.ai_assistant_id || convo.assistant || null; // JOE cuid
+        if (joeAssistantId) {
+            try{
+                // Prefer a direct lookup via the ai_assistant schema, but fall
+                // back to scanning the in-memory dataset if needed. In some
+                // server contexts $J.get may not be wired for ai_assistant yet,
+                // while JOE.Data.ai_assistant is available.
+                assistantObj = $J.get(joeAssistantId,'ai_assistant') || $J.get(joeAssistantId) || null;
+            }catch(_e){}
+            if (!assistantObj && JOE && JOE.Data && Array.isArray(JOE.Data.ai_assistant)) {
+                assistantObj = JOE.Data.ai_assistant.find(function(a){
+                    return a && (a._id === joeAssistantId);
                 }) || null;
             }
+        }
+        const assistantId = body.assistant_id || convo.assistant_id || (assistantObj && assistantObj.assistant_id) || null;
+        // Legacy fallback: if we only have an OpenAI assistant_id, try to
+        // locate the JOE ai_assistant by that id.
+        if (!assistantObj && assistantId && JOE && JOE.Data && Array.isArray(JOE.Data.ai_assistant)) {
+            assistantObj = JOE.Data.ai_assistant.find(function (a) {
+                return a && a.assistant_id === assistantId;
+            }) || null;
+        }
+
+        // Log which ai_assistant (if any) is being used for this widget
+        // conversation so we can easily confirm the active agent when
+        // debugging object chat vs AI Hub behavior.
+        try{
+            coloredLog('[widget] assistant resolution: '
+                + 'convo.assistant=' + String(convo.assistant || '')
+                + ' convo.assistant_id=' + String(convo.assistant_id || '')
+                + ' body.ai_assistant_id=' + String(body.ai_assistant_id || '')
+                + ' body.assistant_id=' + String(body.assistant_id || '')
+                + ' resolvedJoe=' + String(assistantObj && assistantObj._id || ''));
+            if (assistantObj) {
+                var asstLabel = assistantObj.name || assistantObj.title || assistantObj.info || assistantObj._id || assistantId;
+                coloredLog('[widget] widgetMessage using ai_assistant: '
+                    + asstLabel + ' [' + (assistantObj._id || assistantId || '') + ']'
+                    + ' source=' + String(convo.source || 'widget')
+                    + ' convo=' + String(convo._id || ''));
+            } else if (assistantId) {
+                coloredLog('[widget] widgetMessage assistant_id (no JOE ai_assistant found): '
+                    + assistantId
+                    + ' source=' + String(convo.source || 'widget')
+                    + ' convo=' + String(convo._id || ''));
+            }
+        }catch(_e){}
+
             const openai = newClient();
             const model = (assistantObj && assistantObj.ai_model) || convo.model || body.model || "gpt-5.1";
 
@@ -1741,6 +1862,33 @@ this.executeJOEAiPrompt = async function(data, req, res) {
                 }
             }catch(_e){ /* non-fatal */ }
 
+            // Append MCP tool instructions for assistants that have MCP enabled,
+            // using the same helper as other MCP-aware surfaces.
+            try{
+                if (assistantObj && assistantObj.mcp_enabled) {
+                    const mcpCfg = {
+                        mcp_enabled: assistantObj.mcp_enabled,
+                        mcp_toolset: assistantObj.mcp_toolset,
+                        mcp_selected_tools: assistantObj.mcp_selected_tools,
+                        mcp_instructions_mode: assistantObj.mcp_instructions_mode || 'auto'
+                    };
+                    const mcp = buildMcpToolsFromConfig(mcpCfg);
+                    coloredLog('[widget] MCP config for assistant '
+                        + String(assistantObj._id || '') + ': enabled=' + String(mcpCfg.mcp_enabled)
+                        + ' toolset=' + String(mcpCfg.mcp_toolset || '')
+                        + ' names=' + JSON.stringify(mcp.names || []));
+                    if (mcp.names && mcp.names.length) {
+                        const txt = MCP.buildToolInstructions(mcp.names, mcpCfg.mcp_instructions_mode || 'auto');
+                        if (txt) {
+                            coloredLog('[widget] appending MCP instructions block to systemText');
+                            systemText = (systemText || '') + '\n\n' + txt;
+                        }
+                    }
+                } else {
+                    coloredLog('[widget] MCP disabled for this assistant or assistant missing; no MCP block appended.');
+                }
+            }catch(_e){ /* non-fatal */ }
+
             // Build the messages array for the model. We deliberately separate
             // the stored `convo.messages` from the model-facing payload so we
             // can annotate the latest user turn with uploaded_files metadata

package/server/plugins/formBuilder.js

@@ -335,6 +335,104 @@ function FormBuilder(){
         }
     }//end bodycontent
 
+    /**
+     * Get form definition JSON from an include
+     * GET /API/plugin/formBuilder/definition?include_id={id}
+     * GET /API/plugin/formBuilder/definition?formid={form_id}&field=json_definition_include
+     * GET /API/plugin/formBuilder/definition?formid={form_id}&pageid={page_id} (auto-finds JSON from page includes)
+     */
+    this.definition = function(data, req, res) {
+        var includeId = data.include_id;
+        var formId = data.formid;
+        var pageId = data.pageid;
+        var includeField = data.field || 'json_definition_include';
+        
+        // If formid provided, look up the include from form's meta, page includes, or specified field
+        if (formId && !includeId) {
+            var form = JOE.Cache.findByID('form', formId);
+            if (!form) {
+                return res.status(404).json({errors: 'form not found', failedat: 'formBuilder'});
+            }
+            
+            // First try: Check if form has a reference to include in meta or a direct field
+            if (form.meta && form.meta[includeField]) {
+                includeId = form.meta[includeField];
+            } else if (form[includeField]) {
+                includeId = form[includeField];
+            } 
+            // Second try: If pageid provided, find JSON include from page's includes
+            else if (pageId) {
+                var page = JOE.Cache.findByID('page', pageId);
+                if (page && page.includes && Array.isArray(page.includes)) {
+                    for (var i = 0; i < page.includes.length; i++) {
+                        var inc = JOE.Cache.findByID('include', page.includes[i]);
+                        if (inc && inc.filetype === 'json') {
+                            includeId = inc._id;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            if (!includeId) {
+                return res.status(404).json({errors: 'form does not have json definition include reference. Set it in form.meta.json_definition_include or add a JSON include to the page', failedat: 'formBuilder'});
+            }
+        }
+        
+        if (!includeId) {
+            return res.status(400).json({errors: 'include_id or formid required', failedat: 'formBuilder'});
+        }
+        
+        var include = JOE.Cache.findByID('include', includeId);
+        if (!include) {
+            return res.status(404).json({errors: 'include not found', failedat: 'formBuilder'});
+        }
+        
+        if (include.filetype !== 'json') {
+            return res.status(400).json({errors: 'include is not a JSON file', failedat: 'formBuilder'});
+        }
+        
+        var content = include.content;
+        
+        // If fillTemplate is enabled, process template variables
+        if (include.fillTemplate) {
+            var payload = {
+                WEBCONFIG: JOE.webconfig,
+                SETTING: JOE.Cache.settings,
+                REQUEST: req,
+                FORM: formId ? JOE.Cache.findByID('form', formId) : null
+            };
+            try {
+                var fillTemplate = require('../modules/Sites.js').fillTemplate || function(str, data) {
+                    return str.replace(/\$\{this\.([^}]+)\}/g, function(match, path) {
+                        var parts = path.split('.');
+                        var val = data;
+                        for (var i = 0; i < parts.length; i++) {
+                            if (val && typeof val === 'object') {
+                                val = val[parts[i]];
+                            } else {
+                                return match;
+                            }
+                        }
+                        return val != null ? val : match;
+                    });
+                };
+                content = fillTemplate(content, payload);
+            } catch(e) {
+                console.error('[formBuilder.definition] template fill error:', e);
+            }
+        }
+        
+        // Parse and return JSON
+        try {
+            var jsonData = typeof content === 'string' ? JSON.parse(content) : content;
+            res.set('Content-Type', 'application/json');
+            return res.json(jsonData);
+        } catch(e) {
+            return res.status(500).json({errors: 'invalid JSON: ' + e.message, failedat: 'formBuilder'});
+        }
+    };
+    
     return self; 
 }
 module.exports = new FormBuilder();

package/server/schemas/ai_assistant.js

@@ -42,6 +42,11 @@ var schema = {
             { name:'tags', type:'string', isArray:true, isReference:true, targetSchema:'tag' },
             { name:'status', type:'string', isReference:true, targetSchema:'status' },
             { name:'last_synced', type:'string', format:'date-time' },
+            // MCP configuration for assistants (mirrors ai_prompt / ai_response)
+            { name:'mcp_enabled', type:'boolean' },
+            { name:'mcp_toolset', type:'string' },
+            { name:'mcp_selected_tools', type:'string', isArray:true },
+            { name:'mcp_instructions_mode', type:'string' },
             { name:'joeUpdated', type:'string', format:'date-time' },
             { name:'created', type:'string', format:'date-time' }
         ]
@@ -64,6 +69,7 @@ var schema = {
         (new Set(schemas)).map(function(schema){
             subs.push({name:schema,filter:{datasets:{$in:[schema]}}})
         });
+        subs = subs.concat({name:'mcp_enabled',filter:{mcp_enabled:true}});
         return subs;
     },
     stripeColor: function(ai_assistant) {
@@ -353,30 +359,35 @@ var schema = {
           "itemtype",
         { section_end: "system" },
         { sidebar_start: "right", collapsed: false },
-        "tags",
-        "status",
-        { 
-            name: "last_synced",
-            type: "date",
-            display: "Last Synced",
-            locked:true,
-            comment: "Last time this Assistant was updated at OpenAI."
-        },
-        {
-            name: "sync_button",
-            type: "button",
-            display: "Sync to OpenAI",
-            method: "syncAssistantToOpenAI",
-            color: "green",
-            title: "Sync this Assistant with OpenAI"
-          },
-          {
-            name: "set_default_assistant",
-            type: "button",
-            display: "Set as Default Assistant",
-            method: "setAsDefaultAssistant",
-            color: "orange",
-            hidden:function(ai_assistant){
+          { section_start:'workflow' },
+            "status",
+            "tags",
+            "last_synced",
+            {
+              name: "sync_button",
+              type: "button",
+              display: "Sync to OpenAI",
+              method: "syncAssistantToOpenAI",
+              color: "green",
+              title: "Sync this Assistant with OpenAI"
+            },
+            {
+              name: "set_default_assistant",
+              type: "button",
+              display: "Set as Default Assistant",
+              method: "setAsDefaultAssistant",
+              color: "orange",
+              hidden:function(ai_assistant){
+                try{
+                  var settings = (_joe && _joe.Data && _joe.Data.setting) || [];
+                  var existing = settings.where({name:'DEFAULT_AI_ASSISTANT'})[0] || null;
+                  return !!(existing && existing.value === ai_assistant._id);
+                }catch(e){
+                  return false;
+                }
+              },
+            title: "Mark this assistant as the DEFAULT_AI_ASSISTANT setting.",
+            locked:function(ai_assistant){
               try{
                 var settings = (_joe && _joe.Data && _joe.Data.setting) || [];
                 var existing = settings.where({name:'DEFAULT_AI_ASSISTANT'})[0] || null;
@@ -384,27 +395,15 @@ var schema = {
               }catch(e){
                 return false;
               }
-            },
-          title: "Mark this assistant as the DEFAULT_AI_ASSISTANT setting.",
-          locked:function(ai_assistant){
-            try{
-              var settings = (_joe && _joe.Data && _joe.Data.setting) || [];
-              var existing = settings.where({name:'DEFAULT_AI_ASSISTANT'})[0] || null;
-              return !!(existing && existing.value === ai_assistant._id);
-            }catch(e){
-              return false;
             }
-          }
-          },
-        // {
-        //     name: "test_button",
-        //     type: "button",
-        //     display: "Test Button",
-        //     method: "testButtonClick",    // <- the method name you want to call
-        //     color: "orange",              // <- Joe color class (joe-orange-button)
-        //     title: "Click to test button functionality",
-        //     schema: "ai_assistant"        // <- schema to pull the method from (optional for now, we lock it anyway)
-        //   },
+            },
+          { section_end:'workflow' },
+          { section_start:'mcp', display:'MCP Tools', collapsed:true },
+            'mcp_enabled',
+            'mcp_toolset',
+            'mcp_selected_tools',
+            'mcp_instructions_mode',
+          { section_end:'mcp' },
         { sidebar_end: "right" },
 
       ];