json-object-editor 0.10.625 → 0.10.632

package/server/plugins/chatgpt.js

@@ -1,6 +1,7 @@
 const OpenAI = require("openai");
 const { google } = require('googleapis');
 const path = require('path');
+const MCP = require("../modules/MCP.js");
 // const { name } = require("json-object-editor/server/webconfig");
 
 function ChatGPT() {
@@ -55,6 +56,349 @@ function ChatGPT() {
         const summary = JOE.Schemas && JOE.Schemas.summary && JOE.Schemas.summary[name];
         return { full, summary };
     }
+    /**
+     * callMCPTool
+     *
+     * Small, well‑scoped helper to invoke a JOE MCP tool directly in‑process,
+     * without going over HTTP or worrying about POST size limits.
+     *
+     * Usage:
+     *   const result = await callMCPTool('listSchemas', {}, { req });
+     *
+     * Notes:
+     *   - `toolName` must exist on MCP.tools.
+     *   - `params` should be a plain JSON-serializable object.
+     *   - `ctx` is optional and can pass `{ req }` or other context that MCP
+     *     tools might want (for auth, user, etc.).
+     */
+    async function callMCPTool(toolName, params = {}, ctx = {}) {
+        if (!MCP || !MCP.tools) {
+            throw new Error("MCP module not initialized; cannot call MCP tool");
+        }
+        if (!toolName || typeof toolName !== 'string') {
+            throw new Error("Missing or invalid MCP tool name");
+        }
+        const fn = MCP.tools[toolName];
+        if (typeof fn !== 'function') {
+            throw new Error(`MCP tool "${toolName}" not found`);
+        }
+        try {
+            // All MCP tools accept (params, ctx) and return a JSON-serializable result.
+            // The Responses / tools API often returns arguments as a JSON string, so
+            // normalize that here before invoking the tool.
+            let toolParams = params;
+            if (typeof toolParams === 'string') {
+                try {
+                    toolParams = JSON.parse(toolParams);
+                } catch (parseErr) {
+                    console.error(`[chatgpt] Failed to JSON-parse tool arguments for "${toolName}"`, parseErr, toolParams);
+                    // Fall back to passing the raw string so tools that expect it still work.
+                }
+            }
+            const result = await fn(toolParams || {}, ctx || {});
+            return result;
+        } catch (e) {
+            // Surface a clean error upstream but keep details in logs.
+            console.error(`[chatgpt] MCP tool "${toolName}" error:`, e);
+            throw new Error(`MCP tool "${toolName}" failed: ${e && e.message || 'Unknown error'}`);
+        }
+    }
+
+    /**
+     * extractToolCalls
+     *
+     * Best-effort parser for tool calls from a Responses API result.
+     * The Responses output shape may evolve; this function looks for
+     * any "tool_call" typed content in response.output[*].content[*]
+     * and normalizes it into `{ name, arguments }` objects.
+     */
+    function extractToolCalls(response) {
+        var calls = [];
+        if (!response || !Array.isArray(response.output)) { return calls; }
+
+        response.output.forEach(function (item) {
+            if (!item) { return; }
+            // v1-style: item.type === 'tool_call'
+            if (item.type === 'function_call') {
+                calls.push({
+                    name: item.name || item.function_name,
+                    arguments: item.arguments || item.function_arguments || {}
+                });
+            }
+            // message-style: item.content is an array of parts
+            if (Array.isArray(item.content)) {
+                item.content.forEach(function (part) {
+                    if (!part) { return; }
+                    if (part.type === 'function_call') {
+                        calls.push({
+                            name: part.name || part.tool_name,
+                            arguments: part.arguments || part.args || {}
+                        });
+                    }
+                });
+            }
+        });
+
+        return calls;
+    }
+
+// Detect "request too large / token limit" style errors from the Responses API.
+function isTokenLimitError(err) {
+    if (!err || typeof err !== 'object') return false;
+    if (err.status !== 429 && err.status !== 400) return false;
+    const msg = (err.error && err.error.message) || err.message || '';
+    if (!msg) return false;
+    const lower = String(msg).toLowerCase();
+    // Cover common phrasing from OpenAI for context/TPM limits.
+    return (
+        lower.includes('request too large') ||
+        lower.includes('too many tokens') ||
+        lower.includes('max tokens') ||
+        lower.includes('maximum context length') ||
+        lower.includes('tokens per min')
+    );
+}
+
+// Create a compact representation of a JOE object for use in slim payloads.
+function slimJOEObject(item) {
+    if (!item || typeof item !== 'object') return item;
+    const name = item.name || item.title || item.label || item.email || item.slug || item._id || '';
+    const info = item.info || item.description || item.summary || '';
+    return {
+        _id: item._id,
+        itemtype: item.itemtype,
+        name: name,
+        info: info
+    };
+}
+
+// Given an `understandObject` result, produce a slimmed version:
+// - keep `object` as-is
+// - keep `flattened` for the main object (depth-limited) if present
+// - replace each related entry with { field, _id, itemtype, object:{_id,itemtype,name,info} }
+// - preserve `schemas`, `tags`, `statuses`, and mark `slim:true`
+function slimUnderstandObjectResult(result) {
+    if (!result || typeof result !== 'object') return result;
+    const out = {
+        _id: result._id,
+        itemtype: result.itemtype,
+        object: result.object,
+        // retain main flattened view if available; this is typically much smaller
+        flattened: result.flattened || null,
+        schemas: result.schemas || {},
+        tags: result.tags || {},
+        statuses: result.statuses || {},
+        slim: true
+    };
+    if (Array.isArray(result.related)) {
+        out.related = result.related.map(function (rel) {
+            if (!rel) return rel;
+            const base = rel.object || {};
+            const slim = slimJOEObject(base);
+            return {
+                field: rel.field,
+                _id: slim && slim._id || rel._id,
+                itemtype: slim && slim.itemtype || rel.itemtype,
+                object: slim
+            };
+        });
+    } else {
+        out.related = [];
+    }
+    return out;
+}
+
+// Walk the messages array and, for any system message containing a JSON payload
+// of the form { "tool": "understandObject", "result": {...} }, replace the
+// result with a slimmed version to reduce token count. Returns a new array; if
+// nothing was changed, returns the original array.
+function shrinkUnderstandObjectMessagesForTokens(messages) {
+    if (!Array.isArray(messages)) return messages;
+    let changed = false;
+    const shrunk = messages.map(function (msg) {
+        if (!msg || msg.role !== 'system') return msg;
+        if (typeof msg.content !== 'string') return msg;
+        try {
+            const parsed = JSON.parse(msg.content);
+            if (!parsed || parsed.tool !== 'understandObject' || !parsed.result) {
+                return msg;
+            }
+            const slimmed = slimUnderstandObjectResult(parsed.result);
+            changed = true;
+            return {
+                ...msg,
+                content: JSON.stringify({ tool: 'understandObject', result: slimmed })
+            };
+        } catch (_e) {
+            return msg;
+        }
+    });
+    return changed ? shrunk : messages;
+}
+
+    /**
+     * runWithTools
+     *
+     * Single orchestration function for calling the OpenAI Responses API
+     * with optional tools (sourced from a JOE `ai_assistant`), handling
+     * tool calls via MCP, and issuing a follow-up model call with the
+     * tool results injected.
+     *
+     * Inputs (opts):
+     *   - openai:  OpenAI client instance
+     *   - model:   model name to use (e.g. "gpt-4.1-mini", "gpt-5.1")
+     *   - systemText: string of system / instructions text
+     *   - messages:   array of { role, content } for the conversation so far
+     *   - assistant:  JOE `ai_assistant` object (may contain `tools`)
+     *   - req:        Express request (passed into MCP tools as context)
+     *
+     * Returns:
+     *   - { response, finalText, messages, toolCalls }
+     *     where `finalText` is the assistant-facing text (from output_text)
+     *     and `messages` is the possibly-extended message list including
+     *     any synthetic `tool` messages.
+     */
+    async function runWithTools(opts) {
+        const openai = opts.openai;
+        const model = opts.model;
+        const systemText = opts.systemText || "";
+        const messages = Array.isArray(opts.messages) ? opts.messages.slice() : [];
+        const assistant = opts.assistant || null;
+        const req = opts.req;
+
+        // 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;
+        if (assistant && assistant.tools) {
+            if (Array.isArray(assistant.tools)) {
+                tools = assistant.tools;
+            } else if (typeof assistant.tools === 'string') {
+                try {
+                    const parsed = JSON.parse(assistant.tools);
+                    if (Array.isArray(parsed)) {
+                        tools = 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) {
+                if (t && t.type === 'function' && t.function && !t.name) {
+                    const fn = t.function || {};
+                    return {
+                        type: 'function',
+                        name: fn.name,
+                        description: fn.description,
+                        parameters: fn.parameters || {}
+                    };
+                }
+                return t;
+            });
+        }
+
+        // No tools configured – do a simple single Responses call.
+        if (!tools) {
+            const resp = await openai.responses.create({
+                model: model,
+                instructions: systemText,
+                input: messages
+            });
+            return {
+                response: resp,
+                finalText: resp.output_text || "",
+                messages: messages,
+                toolCalls: []
+            };
+        }
+
+        // Step 1: call the model with tools enabled.
+        const first = await openai.responses.create({
+            model: model,
+            instructions: systemText,
+            input: messages,
+            tools: tools,
+            tool_choice: "auto"
+        });
+
+        const toolCalls = extractToolCalls(first);
+
+        // If the model didn't decide to use tools, just return the first answer.
+        if (!toolCalls.length) {
+            return {
+                response: first,
+                finalText: first.output_text || "",
+                messages: messages,
+                toolCalls: []
+            };
+        }
+
+        // Step 2: execute each tool call via MCP and append tool results.
+        for (let i = 0; i < toolCalls.length; i++) {
+            const tc = toolCalls[i];
+            try {
+                const result = await callMCPTool(tc.name, tc.arguments || {}, { req });
+                messages.push({
+                    // Responses API does not support a "tool" role in messages.
+                    // We inject tool outputs as a synthetic system message so
+                    // the model can see the results without affecting the
+                    // user/assistant turn structure.
+                    role: "system",
+                    content: JSON.stringify({ tool: tc.name, result: result })
+                });
+            } catch (e) {
+                console.error("[chatgpt] MCP tool error in runWithTools:", e);
+                messages.push({
+                    role: "system",
+                    content: JSON.stringify({
+                        tool: tc.name,
+                        error: e && e.message || "Tool execution failed"
+                    })
+                });
+            }
+        }
+
+        // Step 3: ask the model again with tool outputs included.
+        let finalMessages = messages;
+        let second;
+        try {
+            second = await openai.responses.create({
+                model: model,
+                instructions: systemText,
+                input: finalMessages
+            });
+        } catch (e) {
+            if (isTokenLimitError(e)) {
+                console.warn("[chatgpt] Responses token limit hit; shrinking understandObject payloads and retrying once");
+                const shrunk = shrinkUnderstandObjectMessagesForTokens(finalMessages);
+                // If nothing was shrunk, just rethrow the original error.
+                if (shrunk === finalMessages) {
+                    throw e;
+                }
+                finalMessages = shrunk;
+                // Retry once with the smaller payload; let any error bubble up.
+                second = await openai.responses.create({
+                    model: model,
+                    instructions: systemText,
+                    input: finalMessages
+                });
+            } else {
+                throw e;
+            }
+        }
+
+        return {
+            response: second,
+            finalText: second.output_text || "",
+            messages: finalMessages,
+            toolCalls: toolCalls
+        };
+    }
 
     // function newClient(){
     //     var key = getAPIKey();
@@ -235,6 +579,35 @@ function ChatGPT() {
         }
     }
 
+    // Normalize model output that should contain JSON. Models often wrap JSON
+    // in markdown fences (```json ... ```); this helper strips fences and
+    // attempts to isolate the first well-formed JSON object substring.
+    function extractJsonText(raw) {
+        if (!raw) { return ''; }
+        let t = String(raw).trim();
+        // Strip leading ```... fence
+        if (t.startsWith('```')) {
+            const firstNewline = t.indexOf('\n');
+            if (firstNewline !== -1) {
+                t = t.substring(firstNewline + 1);
+            }
+            const lastFence = t.lastIndexOf('```');
+            if (lastFence !== -1) {
+                t = t.substring(0, lastFence);
+            }
+            t = t.trim();
+        }
+        // If there's extra prose around the JSON, slice from first { to last }
+        if (t[0] !== '{') {
+            const firstBrace = t.indexOf('{');
+            const lastBrace = t.lastIndexOf('}');
+            if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+                t = t.slice(firstBrace, lastBrace + 1);
+            }
+        }
+        return t.trim();
+    }
+
     // Autofill feature (Responses API; supports assistant_id or model)
     this.autofill = async function (data, req, res) {
         const startedAt = Date.now();
@@ -285,22 +658,11 @@ function ChatGPT() {
             const openai = newClient();
             const model = body.model || 'gpt-4o-mini';
 
+            // For simplicity and robustness, use plain text output and instruct the
+            // model to return a strict JSON object. We previously attempted the
+            // Responses `json_schema` response_format, but the SDK shape can change
+            // and is harder to parse reliably; text + JSON.parse is sufficient here.
             const requestBase = {
-                response_format: {
-                    type: 'json_schema',
-                    json_schema: {
-                        name: 'joe_autofill_patch',
-                        strict: true,
-                        schema: {
-                            type: 'object',
-                            additionalProperties: false,
-                            required: ['patch'],
-                            properties: {
-                                patch: { type: 'object', additionalProperties: true }
-                            }
-                        }
-                    }
-                },
                 temperature: 0.2,
                 instructions: systemText,
                 input: userInput
@@ -315,6 +677,7 @@ function ChatGPT() {
 
             let textOut = '';
             try { textOut = response.output_text || ''; } catch (_e) {}
+            coloredLog("textOut: "+textOut);
             if (!textOut && response && Array.isArray(response.output)) {
                 for (let i = 0; i < response.output.length; i++) {
                     const item = response.output[i];
@@ -330,10 +693,13 @@ function ChatGPT() {
 
             let patch = {};
             try {
-                const parsed = JSON.parse(textOut || '{}');
+                const jsonText = extractJsonText(textOut);
+                const parsed = JSON.parse(jsonText || '{}');
                 patch = parsed.patch || {};
-            } catch (_e) {}
-
+            } catch (_e) {
+                console.warn('[chatgpt.autofill] Failed to parse JSON patch from model output', _e);
+            }
+            coloredLog("patch: "+JSON.stringify(patch));
             const filteredPatch = {};
             fields.forEach(function (f) {
                 if (Object.prototype.hasOwnProperty.call(patch, f)) {
@@ -565,19 +931,60 @@ this.executeJOEAiPrompt = async function(data, req, res) {
         });
     }
 
+    /**
+     * widgetStart
+     *
+     * Purpose:
+     *   Create and persist a new `ai_widget_conversation` record for the
+     *   external `<joe-ai-widget>` chat component. This is a lightweight
+     *   conversation record that stores model, assistant, system text and
+     *   messages for the widget.
+     *
+     * Inputs (data):
+     *   - model            (optional) override model for the widget
+     *   - ai_assistant_id  (optional) JOE ai_assistant cuid
+     *   - system           (optional) explicit system text
+     *   - source           (optional) freeform source tag, defaults to "widget"
+     *
+     * OpenAI calls:
+     *   - None. This endpoint only touches storage.
+     *
+     * Output:
+     *   - { success, conversation_id, model, assistant_id }
+     *     where assistant_id is the OpenAI assistant_id (if present).
+     */
     this.widgetStart = async function (data, req, res) {
         try {
             var body = data || {};
-            var model = body.model || "gpt-4.1-mini";
+            // Default to a modern chat model when no assistant/model is provided.
+            // If an assistant is supplied, its ai_model will override this.
+            var model = body.model || "gpt-5.1";
             var assistant = body.ai_assistant_id ? $J.get(body.ai_assistant_id) : null;
             var system = body.system || (assistant && assistant.instructions) || "";
+            // Prefer explicit user fields coming from the client (ai-widget-test page
+            // passes _joe.User fields). Widget endpoints no longer infer from req.User
+            // to keep a single, explicit source of truth.
+            var user = null;
+            if (body.user_id || body.user_name || body.user_color) {
+                user = {
+                    _id: body.user_id,
+                    name: body.user_name,
+                    fullname: body.user_name,
+                    color: body.user_color
+                };
+            }
+            var user_color = (body.user_color) || (user && user.color) || null;
 
             var convo = {
                 _id: (typeof cuid === 'function') ? cuid() : undefined,
                 itemtype: "ai_widget_conversation",
-                model: assistant && assistant.ai_model || model,
+                model: (assistant && assistant.ai_model) || model,
                 assistant: assistant && assistant._id,
                 assistant_id: assistant && assistant.assistant_id,
+                assistant_color: assistant && assistant.assistant_color,
+                user: user && user._id,
+                user_name: user && (user.fullname || user.name),
+                user_color: user_color,
                 system: system,
                 messages: [],
                 source: body.source || "widget",
@@ -586,17 +993,20 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             };
 
             const saved = await new Promise(function (resolve, reject) {
+                // Widget conversations are lightweight and do not need full history diffs.
                 JOE.Storage.save(convo, "ai_widget_conversation", function (err, result) {
                     if (err) return reject(err);
                     resolve(result);
-                });
+                }, { history: false });
             });
 
             return {
                 success: true,
                 conversation_id: saved._id,
                 model: saved.model,
-                assistant_id: saved.assistant_id || null
+                assistant_id: saved.assistant_id || null,
+                assistant_color: saved.assistant_color || null,
+                user_color: saved.user_color || user_color || null
             };
         } catch (e) {
             console.error("[chatgpt] widgetStart error:", e);
@@ -604,6 +1014,22 @@ this.executeJOEAiPrompt = async function(data, req, res) {
         }
     };
 
+    /**
+     * widgetHistory
+     *
+     * Purpose:
+     *   Load an existing `ai_widget_conversation` and normalize its
+     *   messages for use by `<joe-ai-widget>` on page load or refresh.
+     *
+     * Inputs (data):
+     *   - conversation_id or _id: the widget conversation cuid
+     *
+     * OpenAI calls:
+     *   - None. Purely storage + normalization.
+     *
+     * Output:
+     *   - { success, conversation_id, model, assistant_id, messages }
+     */
     this.widgetHistory = async function (data, req, res) {
         try {
             var conversation_id = data.conversation_id || data._id;
@@ -626,6 +1052,8 @@ this.executeJOEAiPrompt = async function(data, req, res) {
                 conversation_id: convo._id,
                 model: convo.model,
                 assistant_id: convo.assistant_id || null,
+                assistant_color: convo.assistant_color || null,
+                user_color: convo.user_color || null,
                 messages: convo.messages
             };
         } catch (e) {
@@ -634,6 +1062,35 @@ this.executeJOEAiPrompt = async function(data, req, res) {
         }
     };
 
+    /**
+     * widgetMessage
+     *
+     * Purpose:
+     *   Handle a single user turn for `<joe-ai-widget>`:
+     *   - Append the user message to the stored conversation.
+     *   - Call OpenAI Responses (optionally with tools from the selected
+     *     `ai_assistant`, via runWithTools + MCP).
+     *   - Append the assistant reply, persist the conversation, and return
+     *     the full message history plus the latest assistant message.
+     *
+     * Inputs (data):
+     *   - conversation_id or _id: cuid of the widget conversation
+     *   - content:               user text
+     *   - role:                  user role, defaults to "user"
+     *   - assistant_id:          optional OpenAI assistant_id (used only to
+     *                            locate the JOE ai_assistant config)
+     *   - model:                 optional model override
+     *
+     * OpenAI calls:
+     *   - responses.create (once if no tools; twice when tools are present):
+     *       * First call may include tools (assistant.tools) and `tool_choice:"auto"`.
+     *       * Any tool calls are executed via MCP and injected as `tool` messages.
+     *       * Second call is plain Responses with updated messages.
+     *
+     * Output:
+     *   - { success, conversation_id, model, assistant_id, messages,
+     *       last_message, usage }
+     */
     this.widgetMessage = async function (data, req, res) {
         try {
             var body = data || {};
@@ -662,30 +1119,80 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             const userMsg = { role: role, content: content, created_at: nowIso };
             convo.messages.push(userMsg);
 
-            const openai = newClient();
+            // Backfill user metadata (id/name/color) on older conversations that
+            // were created before we started storing these fields. Prefer explicit
+            // body fields only; we no longer infer from req.User so that widget
+            // calls always have a single, explicit user source.
+            var u = null;
+            if (body.user_id || body.user_name || body.user_color) {
+                u = {
+                    _id: body.user_id,
+                    name: body.user_name,
+                    fullname: body.user_name,
+                    color: body.user_color
+                };
+            }
+            if (u) {
+                if (!convo.user && u._id) {
+                    convo.user = u._id;
+                }
+                if (!convo.user_name && (u.fullname || u.name)) {
+                    convo.user_name = u.fullname || u.name;
+                }
+                if (!convo.user_color && u.color) {
+                    convo.user_color = u.color;
+                }
+            }
+
             const assistantId = body.assistant_id || convo.assistant_id || null;
-            const model = convo.model || body.model || "gpt-4.1-mini";
+            // 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;
+                }) || null;
+            }
+            const openai = newClient();
+            const model = (assistantObj && assistantObj.ai_model) || convo.model || body.model || "gpt-5.1";
 
-            const systemText = convo.system || "";
+            // Prefer explicit system text on the conversation, then assistant instructions.
+            const systemText = (convo.system && String(convo.system)) ||
+                (assistantObj && assistantObj.instructions) ||
+                "";
             const messagesForModel = convo.messages.map(function (m) {
                 return { role: m.role, content: m.content };
             });
 
-            let response;
-            if (assistantId) {
-                response = await openai.responses.create({
-                    assistant_id: assistantId,
-                    input: messagesForModel
-                });
-            } else {
-                response = await openai.responses.create({
-                    model: model,
-                    instructions: systemText,
-                    input: messagesForModel
+            // Use runWithTools so that, when an assistant has tools configured,
+            // we let the model call those tools via MCP before generating a
+            // final response.
+            const runResult = await runWithTools({
+                openai: openai,
+                model: model,
+                systemText: systemText,
+                messages: messagesForModel,
+                assistant: assistantObj,
+                req: req
+            });
+
+            // If tools were called this turn, inject a small meta message so the
+            // widget clearly shows which functions ran before the assistant reply.
+            if (runResult.toolCalls && runResult.toolCalls.length) {
+                const names = runResult.toolCalls.map(function (tc) { return tc && tc.name; })
+                    .filter(Boolean)
+                    .join(', ');
+                convo.messages.push({
+                    role: "assistant",
+                    meta: "tools_used",
+                    content: "[Tools used this turn: " + names + "]",
+                    created_at: nowIso
                 });
             }
 
-            const assistantText = response.output_text || "";
+            const assistantText = runResult.finalText || "";
             const assistantMsg = {
                 role: "assistant",
                 content: assistantText,
@@ -696,10 +1203,11 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             convo.joeUpdated = assistantMsg.created_at;
 
             await new Promise(function (resolve, reject) {
+                // Skip history for widget conversations to avoid heavy diffs / craydent.equals issues.
                 JOE.Storage.save(convo, "ai_widget_conversation", function (err, saved) {
                     if (err) return reject(err);
                     resolve(saved);
-                });
+                }, { history: false });
             });
 
             return {
@@ -707,9 +1215,12 @@ this.executeJOEAiPrompt = async function(data, req, res) {
                 conversation_id: convo._id,
                 model: model,
                 assistant_id: assistantId,
+                assistant_color: (assistantObj && assistantObj.assistant_color) || convo.assistant_color || null,
+                user_color: convo.user_color || ((u && u.color) || null),
                 messages: convo.messages,
                 last_message: assistantMsg,
-                usage: response.usage || {}
+                // Usage comes from the underlying Responses call inside runWithTools.
+                usage: (runResult.response && runResult.response.usage) || {}
             };
         } catch (e) {
             console.error("[chatgpt] widgetMessage error:", e);
@@ -717,11 +1228,16 @@ this.executeJOEAiPrompt = async function(data, req, res) {
         }
     };
 
-    this.async={
-        executeJOEAiPrompt:this.executeJOEAiPrompt,
-        testPrompt:this.testPrompt,
-        sendInitialConsultTranscript:this.sendInitialConsultTranscript,
-    }
+    // Mark async plugin methods so Server.pluginHandling will await them.
+    this.async = {
+        executeJOEAiPrompt: this.executeJOEAiPrompt,
+        testPrompt: this.testPrompt,
+        sendInitialConsultTranscript: this.sendInitialConsultTranscript,
+        widgetStart: this.widgetStart,
+        widgetHistory: this.widgetHistory,
+        widgetMessage: this.widgetMessage,
+        autofill: this.autofill,
+    };
     this.protected = [,'testPrompt'];
     return self;
 }