@hawtio/ai-plugin 0.2.1 → 0.3.0

package/dist/index.js

@@ -8,9 +8,6 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -33,6 +30,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/ai-plugin/chat/globals.ts
+var import_react, pluginName, pluginTitle, pluginPath, log;
+var init_globals = __esm({
+  "src/ai-plugin/chat/globals.ts"() {
+    "use strict";
+    import_react = require("@hawtio/react");
+    pluginName = "hawtio-ai-chat";
+    pluginTitle = "AI Chat";
+    pluginPath = "/ai-chat";
+    log = import_react.Logger.get(pluginName);
+  }
+});
+
+// src/ai-plugin/chat/Chat.css
+var init_Chat = __esm({
+  "src/ai-plugin/chat/Chat.css"() {
+  }
+});
+
 // src/ai-plugin/common/ai-model.ts
 var PROVIDERS, MODELS;
 var init_ai_model = __esm({
@@ -67,22 +83,282 @@ var init_ai_model = __esm({
   }
 });
 
-// src/ai-plugin/jmx-ai/globals.ts
-var import_react, pluginName, pluginTitle, pluginPath, log, PARAM_KEY_NODE_ID;
-var init_globals = __esm({
-  "src/ai-plugin/jmx-ai/globals.ts"() {
+// src/ai-plugin/common/ai-preferences-service.ts
+var STORAGE_KEY_PREFERENCES, DEFAULT_TOOL_PERMISSIONS, DEFAULT_MAX_AUTO_TOOL_STEPS, DEFAULT_OPTIONS, AiPreferencesService, aiPreferencesService;
+var init_ai_preferences_service = __esm({
+  "src/ai-plugin/common/ai-preferences-service.ts"() {
     "use strict";
-    import_react = require("@hawtio/react");
-    pluginName = "hawtio-ai-jmx-ai";
-    pluginTitle = "JMX AI";
-    pluginPath = "/jmx-ai";
-    log = import_react.Logger.get(pluginName);
-    PARAM_KEY_NODE_ID = "nid";
+    init_ai_model();
+    init_ai_service();
+    STORAGE_KEY_PREFERENCES = "ai.preferences";
+    DEFAULT_TOOL_PERMISSIONS = {
+      listMBeans: true,
+      getMBeanInfo: true,
+      searchMBeans: true,
+      readMBeanAttribute: false,
+      writeMBeanAttribute: false,
+      executeMBeanOperation: false
+    };
+    DEFAULT_MAX_AUTO_TOOL_STEPS = 10;
+    DEFAULT_OPTIONS = {
+      model: MODELS[0],
+      toolPermissions: DEFAULT_TOOL_PERMISSIONS,
+      maxAutoToolSteps: DEFAULT_MAX_AUTO_TOOL_STEPS
+    };
+    AiPreferencesService = class {
+      loadOptions() {
+        const item = localStorage.getItem(STORAGE_KEY_PREFERENCES);
+        const savedOptions = item ? JSON.parse(item) : {};
+        return { ...DEFAULT_OPTIONS, ...savedOptions };
+      }
+      saveOptions(options) {
+        const updated = { ...this.loadOptions(), ...options };
+        localStorage.setItem(STORAGE_KEY_PREFERENCES, JSON.stringify(updated));
+        if (options.model) {
+          aiService.reset(options.model);
+        }
+      }
+    };
+    aiPreferencesService = new AiPreferencesService();
+  }
+});
+
+// src/ai-plugin/common/globals.ts
+var import_react2, pluginName2, pluginTitle2, log2;
+var init_globals2 = __esm({
+  "src/ai-plugin/common/globals.ts"() {
+    "use strict";
+    import_react2 = require("@hawtio/react");
+    pluginName2 = "hawtio-ai";
+    pluginTitle2 = "AI";
+    log2 = import_react2.Logger.get(pluginName2);
+  }
+});
+
+// src/ai-plugin/common/workspace.ts
+var import_react3, WorkspaceExtension, workspaceExtension;
+var init_workspace = __esm({
+  "src/ai-plugin/common/workspace.ts"() {
+    "use strict";
+    import_react3 = require("@hawtio/react");
+    init_globals2();
+    WorkspaceExtension = class {
+      constructor(workspace5, jolokiaService3) {
+        this.workspace = workspace5;
+        this.jolokiaService = jolokiaService3;
+      }
+      workspace;
+      jolokiaService;
+      async listMBeans() {
+        log2.debug("workspace - listMBeans called");
+        const tree = await this.workspace.getTree();
+        const flat = tree.flatten();
+        const result = Object.keys(flat).sort();
+        log2.debug("workspace - listMBeans result count:", result.length);
+        return result;
+      }
+      async getMBeanInfo(objectName) {
+        log2.debug("workspace - getMBeanInfo called:", objectName);
+        const tree = await this.workspace.getTree();
+        const flat = tree.flatten();
+        const mbeanInfo = flat[objectName]?.mbean ?? null;
+        if (!mbeanInfo) {
+          log2.debug("workspace - getMBeanInfo: not found:", objectName);
+        }
+        return mbeanInfo;
+      }
+      async readMBeanAttribute(objectName, attribute) {
+        log2.debug("workspace - readMBeanAttribute called:", objectName, attribute);
+        return this.jolokiaService.readAttribute(objectName, attribute);
+      }
+      async writeMBeanAttribute(objectName, attribute, value) {
+        log2.debug("workspace - writeMBeanAttribute called:", objectName, attribute, value);
+        return this.jolokiaService.writeAttribute(objectName, attribute, value);
+      }
+      async executeMBeanOperation(objectName, operation, args) {
+        log2.debug("workspace - executeMBeanOperation called:", objectName, operation, args);
+        return this.jolokiaService.execute(objectName, operation, args);
+      }
+    };
+    workspaceExtension = new WorkspaceExtension(import_react3.workspace, import_react3.jolokiaService);
+  }
+});
+
+// src/ai-plugin/common/tools.ts
+function listMBeansTool() {
+  return new import_tools.DynamicStructuredTool({
+    name: "listMBeans",
+    description: `
+      List all MBean ObjectNames available in the Hawtio workspace cache.
+      Use this to discover what MBeans are present before querying details.
+    `,
+    schema: import_zod.z.object({}),
+    func: async () => {
+      log2.debug("tools - listMBeans called");
+      const result = await workspaceExtension.listMBeans();
+      return JSON.stringify(result);
+    }
+  });
+}
+function getMBeanInfoTool() {
+  return new import_tools.DynamicStructuredTool({
+    name: "getMBeanInfo",
+    description: `
+      Return the attribute schema (type, description, read/write flag) and operation definitions
+      (arguments, return type, description) for a specific MBean.
+      Call this before readMBeanAttribute or executeMBeanOperation to inspect available fields.
+    `,
+    schema: import_zod.z.object({
+      objectName: import_zod.z.string().describe("JMX ObjectName of the target MBean, e.g. 'java.lang:type=Memory'")
+    }),
+    func: async ({ objectName }) => {
+      log2.debug("tools - getMBeanInfo called:", objectName);
+      const info = await workspaceExtension.getMBeanInfo(objectName);
+      if (!info) {
+        return JSON.stringify({ error: `MBean not found: ${objectName}` });
+      }
+      return JSON.stringify({ objectName, attr: info.attr, op: info.op });
+    }
+  });
+}
+function searchMBeansTool() {
+  return new import_tools.DynamicStructuredTool({
+    name: "searchMBeans",
+    description: `
+      Search MBeans by JMX domain and property key/value pairs.
+      Returns a list of matching ObjectNames.
+      Use this to narrow down MBeans by type or name, e.g. domain='java.lang', properties='{"type":"Memory"}'.
+    `,
+    schema: import_zod.z.object({
+      domain: import_zod.z.string().describe("JMX domain to search in, e.g. 'java.lang'"),
+      properties: import_zod.z.string().describe(`JSON string of JMX property key/value pairs to match, e.g. '{"type":"Memory"}'`)
+    }),
+    func: async ({ domain, properties }) => {
+      log2.debug("tools - searchMBeans called:", domain, properties);
+      let parsed;
+      try {
+        parsed = JSON.parse(properties);
+      } catch {
+        return JSON.stringify({ error: `Invalid JSON for properties: ${properties}` });
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return JSON.stringify({ error: `properties must be a JSON object, got: ${properties}` });
+      }
+      const nodes = await import_react4.workspace.findMBeans(domain, parsed);
+      const result = nodes.map((n) => n.objectName).filter((s) => s !== void 0);
+      log2.debug("tools - searchMBeans result count:", result.length);
+      return JSON.stringify(result);
+    }
+  });
+}
+function readMBeanAttributeTool() {
+  return new import_tools.DynamicStructuredTool({
+    name: "readMBeanAttribute",
+    description: `
+      Read the current value of an MBean attribute via Jolokia.
+      This is a read-only operation with no side effects.
+      Use getMBeanInfo first to confirm the attribute name and type.
+    `,
+    schema: import_zod.z.object({
+      objectName: import_zod.z.string().describe("ObjectName of the target MBean, e.g. 'java.lang:type=Memory'"),
+      attribute: import_zod.z.string().describe("Name of the attribute to read, e.g. 'HeapMemoryUsage'")
+    }),
+    func: async ({ objectName, attribute }) => {
+      log2.debug("tools - readMBeanAttribute called:", objectName, attribute);
+      try {
+        const value = await workspaceExtension.readMBeanAttribute(objectName, attribute);
+        return JSON.stringify({ objectName, attribute, value });
+      } catch (e) {
+        return JSON.stringify({ error: String(e) });
+      }
+    }
+  });
+}
+function writeMBeanAttributeTool() {
+  return new import_tools.DynamicStructuredTool({
+    name: "writeMBeanAttribute",
+    description: `
+      Write a value to a writable MBean attribute via Jolokia.
+      Verify rw=true with getMBeanInfo before calling this tool.
+    `,
+    schema: import_zod.z.object({
+      objectName: import_zod.z.string().describe("ObjectName of the target MBean, e.g. 'java.lang:type=Memory'"),
+      attribute: import_zod.z.string().describe("Name of the attribute to write"),
+      value: import_zod.z.string().describe('JSON-encoded value to set, e.g. "42" or "true" or "\\"hello\\""')
+    }),
+    func: async ({ objectName, attribute, value }) => {
+      log2.debug("tools - writeMBeanAttribute called:", objectName, attribute, value);
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        parsed = value;
+      }
+      try {
+        const result = await workspaceExtension.writeMBeanAttribute(objectName, attribute, parsed);
+        return JSON.stringify({ objectName, attribute, result });
+      } catch (e) {
+        return JSON.stringify({ error: String(e) });
+      }
+    }
+  });
+}
+function executeMBeanOperationTool() {
+  return new import_tools.DynamicStructuredTool({
+    name: "executeMBeanOperation",
+    description: `
+      Execute an MBean operation via Jolokia.
+      Use getMBeanInfo to verify the operation signature before calling.
+      For overloaded operations include the signature, e.g. 'gc()'.
+    `,
+    schema: import_zod.z.object({
+      objectName: import_zod.z.string().describe("ObjectName of the target MBean, e.g. 'java.lang:type=Memory'"),
+      operation: import_zod.z.string().describe("Operation name to invoke, e.g. 'gc' or 'gc()'"),
+      args: import_zod.z.array(import_zod.z.string()).optional().describe('JSON-encoded arguments to pass to the operation, e.g. ["value1", "42"]')
+    }),
+    func: async ({ objectName, operation, args }) => {
+      log2.debug("tools - executeMBeanOperation called:", objectName, operation, args);
+      const parsedArgs = args?.map((a) => {
+        try {
+          return JSON.parse(a);
+        } catch {
+          return a;
+        }
+      });
+      try {
+        const result = await workspaceExtension.executeMBeanOperation(objectName, operation, parsedArgs);
+        return JSON.stringify({ objectName, operation, result });
+      } catch (e) {
+        return JSON.stringify({ error: String(e) });
+      }
+    }
+  });
+}
+function getWorkspaceTools() {
+  return [
+    listMBeansTool(),
+    getMBeanInfoTool(),
+    searchMBeansTool(),
+    readMBeanAttributeTool(),
+    writeMBeanAttributeTool(),
+    executeMBeanOperationTool()
+  ];
+}
+var import_react4, import_tools, import_zod, WORKSPACE_TOOLS_META;
+var init_tools = __esm({
+  "src/ai-plugin/common/tools.ts"() {
+    "use strict";
+    import_react4 = require("@hawtio/react");
+    import_tools = require("@langchain/core/tools");
+    import_zod = require("zod");
+    init_globals2();
+    init_workspace();
+    WORKSPACE_TOOLS_META = getWorkspaceTools().map(({ name, description }) => ({ name, description }));
   }
 });
 
 // src/ai-plugin/common/ai-service.ts
-var import_anthropic, import_messages, import_google_genai, import_ollama, import_openai, import_patternfly_avatar, import_img_avatar_light, BOT_NAME, TOOLS, TOOLS_BY_NAME, AiService, aiService;
+var import_anthropic, import_messages, import_google_genai, import_ollama, import_openai, import_patternfly_avatar, import_img_avatar_light, import_react5, BOT_NAME, TOOLS, TOOLS_BY_NAME, AiService, aiService;
 var init_ai_service = __esm({
   "src/ai-plugin/common/ai-service.ts"() {
     "use strict";
@@ -93,10 +369,12 @@ var init_ai_service = __esm({
     import_openai = require("@langchain/openai");
     import_patternfly_avatar = __toESM(require("@patternfly/chatbot/patternfly-docs/content/extensions/chatbot/examples/Messages/patternfly_avatar.jpg"));
     import_img_avatar_light = __toESM(require("@patternfly/react-core/dist/styles/assets/images/img_avatar-light.svg"));
-    init_globals();
+    import_react5 = require("react");
     init_ai_preferences_service();
+    init_globals2();
+    init_tools();
     BOT_NAME = "Hawtio AI";
-    TOOLS = [];
+    TOOLS = getWorkspaceTools();
     TOOLS_BY_NAME = TOOLS.reduce(
       (acc, tool) => {
         acc[tool.name] = tool;
@@ -109,11 +387,16 @@ var init_ai_service = __esm({
       llm;
       llmWithTools;
       memory = {};
+      appendToolMessages(messages, toolCalls, content) {
+        for (const call of toolCalls) {
+          messages.push(new import_messages.ToolMessage({ tool_call_id: call.id ?? call.name, content }));
+        }
+      }
       reset(model) {
         if (this.model && this.model.id === model.id && this.llm && (!model.tool || this.llmWithTools)) {
           return;
         }
-        log.info("AI model to use:", model.id);
+        log2.info("AI model to use:", model.id);
         this.memory = {};
         const { token } = aiPreferencesService.loadOptions();
         this.model = model;
@@ -123,7 +406,6 @@ var init_ai_service = __esm({
               this.llm = new import_openai.ChatOpenAI({
                 model: this.model.id,
                 apiKey: token,
-                temperature: 0,
                 streaming: false
               });
               break;
@@ -151,7 +433,7 @@ var init_ai_service = __esm({
               });
           }
         } catch (error) {
-          log.warn("Error initialising AI model:", error);
+          log2.warn("Error initialising AI model:", error);
           this.llm = void 0;
         }
         this.llmWithTools = void 0;
@@ -172,7 +454,7 @@ var init_ai_service = __esm({
       }
       async invoke(messages) {
         const llm = this.getLlm();
-        log.debug("Chatting with", this.model?.id, ":", messages);
+        log2.debug("Chatting with", this.model?.id, ":", messages);
         try {
           let answer;
           if (!llm) {
@@ -180,24 +462,28 @@ var init_ai_service = __esm({
           }
           answer = await llm.invoke(messages);
           if (answer.tool_calls && answer.tool_calls.length > 0) {
-            log.debug("\u{1F6E0}\uFE0F  calls:", answer.tool_calls);
+            log2.debug("\u{1F6E0}\uFE0F  calls:", answer.tool_calls);
           }
-          log.debug("Answer:", answer);
+          log2.debug("Answer:", answer);
           return answer;
         } catch (error) {
-          log.error("Error while chatting:", error);
+          log2.error("Error while chatting:", error);
           return String(error);
         }
       }
-      newChat(dialogId, message, system) {
+      newChat(dialogId, initialMessage, onMessage) {
+        const { message, system } = initialMessage;
         if (system) {
           this.memory[dialogId] = [new import_messages.SystemMessage(system)];
         } else {
           this.memory[dialogId] = [];
         }
-        return this.chat(dialogId, message);
+        return this.chat(dialogId, message, onMessage);
       }
-      async chat(dialogId, message) {
+      hasToolCalls(answer) {
+        return typeof answer !== "string" && (answer.tool_calls?.length ?? 0) > 0;
+      }
+      async chat(dialogId, message, onMessage) {
         let messages = this.memory[dialogId];
         if (!messages) {
           messages = [];
@@ -208,9 +494,26 @@ var init_ai_service = __esm({
         if (typeof answer !== "string") {
           messages.push(answer);
         }
+        log2.debug("Current messages:", messages);
+        if (this.hasToolCalls(answer)) {
+          const { toolPermissions } = aiPreferencesService.loadOptions();
+          if (answer.tool_calls.every((call) => toolPermissions?.[call.name] === true)) {
+            onMessage?.(answer);
+            return this.invokeTools(dialogId, answer.tool_calls, onMessage);
+          }
+        }
         return answer;
       }
-      async invokeTools(dialogId, toolCalls) {
+      /**
+       * Executes the given tool calls and invokes the LLM with the results.
+       * If the LLM responds with further tool calls that are all auto-approved,
+       * this method recurses (up to {@link maxAutoToolSteps} times) to continue
+       * the chain without interruption. Tool calls that are not auto-approved are
+       * returned as-is so the caller can decide to approve or reject them.
+       *
+       * @param step - Current recursion depth; used to enforce the step limit.
+       */
+      async invokeTools(dialogId, toolCalls, onMessage, step = 0) {
         if (!this.llmWithTools) {
           return "Tool invocation not supported";
         }
@@ -219,28 +522,60 @@ var init_ai_service = __esm({
           messages = [];
           this.memory[dialogId] = messages;
         }
-        for (const call of toolCalls) {
-          log.debug("\u{1F6E0}\uFE0F  Call:", call.name, JSON.stringify(call.args));
-          const selectedTool = TOOLS_BY_NAME[call.name];
-          const toolAnswer = await selectedTool?.invoke(call);
-          if (toolAnswer) {
-            log.debug("\u{1F6E0}\uFE0F  " + call.name + ":", toolAnswer);
-            messages.push(toolAnswer);
-          }
+        const { toolPermissions, maxAutoToolSteps } = aiPreferencesService.loadOptions();
+        if (step >= maxAutoToolSteps) {
+          const limitMessage = `Automatic tool-call step limit reached after ${maxAutoToolSteps} steps.`;
+          this.appendToolMessages(messages, toolCalls, limitMessage);
+          log2.warn(`Auto-tool execution stopped after ${maxAutoToolSteps} steps to prevent runaway execution.`);
+          return `Stopped after ${maxAutoToolSteps} automatic tool-call steps. You can increase the limit in Preferences.`;
         }
-        const finalAnswer = await this.llmWithTools.invoke(messages);
-        if (finalAnswer) {
-          messages.push(finalAnswer);
+        try {
+          for (const call of toolCalls) {
+            log2.debug("\u{1F6E0}\uFE0F  Call:", call.name, JSON.stringify(call.args));
+            const selectedTool = TOOLS_BY_NAME[call.name];
+            const toolAnswer = await selectedTool?.invoke(call);
+            if (toolAnswer) {
+              log2.debug("\u{1F6E0}\uFE0F  " + call.name + ":", toolAnswer);
+              messages.push(toolAnswer);
+            }
+          }
+          const answer = await this.llmWithTools.invoke(messages);
+          if (answer) {
+            messages.push(answer);
+          }
+          log2.debug("Messages>>", messages);
+          if (this.hasToolCalls(answer) && answer.tool_calls.every((call) => toolPermissions?.[call.name] === true)) {
+            onMessage?.(answer);
+            return this.invokeTools(dialogId, answer.tool_calls, onMessage, step + 1);
+          }
+          return answer;
+        } catch (error) {
+          log2.error("Error while invoking tools:", error);
+          return String(error);
         }
-        console.debug("Messages>>", messages);
-        return finalAnswer;
+      }
+      rejectTools(dialogId, toolCalls) {
+        const messages = this.memory[dialogId];
+        if (!messages) return;
+        this.appendToolMessages(messages, toolCalls, "User rejected");
+        log2.debug(
+          "rejectTools - added rejection ToolMessages for:",
+          toolCalls.map((c) => c.name)
+        );
       }
       generateId() {
         return crypto.randomUUID();
       }
       createUserMessage(name, content) {
         const id = this.generateId();
-        return { id, role: "user", content, name, avatar: import_img_avatar_light.default };
+        return {
+          id,
+          role: "user",
+          content,
+          name,
+          avatar: import_img_avatar_light.default,
+          timestamp: (/* @__PURE__ */ new Date()).toLocaleString()
+        };
       }
       createLoadingBotMessage() {
         const id = this.generateId();
@@ -249,6 +584,7 @@ var init_ai_service = __esm({
           role: "bot",
           name: BOT_NAME,
           avatar: import_patternfly_avatar.default,
+          avatarProps: { style: { fontSize: "90%" } },
           content: "API response goes here",
           isLoading: true
         };
@@ -260,2964 +596,556 @@ var init_ai_service = __esm({
           role: "bot",
           name: BOT_NAME,
           avatar: import_patternfly_avatar.default,
+          avatarProps: { style: { fontSize: "90%" } },
           content,
           extraContent,
-          isLoading: false
+          isLoading: false,
+          timestamp: (/* @__PURE__ */ new Date()).toLocaleString()
         };
       }
       extractThink(message) {
-        const think = message.match(/<think>(.*?)<\/think>/s)?.[1]?.trim();
-        const content = message.replace(/<think>.*?<\/think>/s, "");
-        log.debug("extractThink - content:", content, "think:", think);
+        const content = message.content;
+        let think;
+        if (message.additional_kwargs?.reasoning_content) {
+          think = message.additional_kwargs?.reasoning_content;
+        }
         return { content, think };
       }
-      toBotMessage(answer, thinkInfo, toolCallsInfo, toolCallsApprove) {
+      toBotMessage(answer, autoApproved, ThinkInfo2, ToolCallsInfo2, ToolCallsApprove2) {
         if (typeof answer === "string") {
-          return aiService.createBotMessage(`Error: ${answer}`);
+          return this.createBotMessage(`Error: ${answer}`);
         }
         if (!answer.tool_calls || answer.tool_calls.length === 0) {
-          const { content: content2, think } = aiService.extractThink(answer.content);
-          const extraContent2 = think ? { beforeMainContent: thinkInfo(think) } : void 0;
-          return aiService.createBotMessage(content2, extraContent2);
+          const { content: content2, think } = this.extractThink(answer);
+          const extraContent = think ? { beforeMainContent: (0, import_react5.createElement)(ThinkInfo2, { think }) } : void 0;
+          return this.createBotMessage(content2, extraContent);
         }
         const toolCalls = answer.tool_calls;
-        const content = `${BOT_NAME} wants to use ` + (toolCalls.length > 1 ? "tools" : "a tool");
-        const extraContent = {
-          beforeMainContent: toolCalls.map(toolCallsInfo),
-          afterMainContent: toolCallsApprove(toolCalls)
+        const isMultiple = toolCalls.length > 1;
+        const toolNames = toolCalls.map((call) => `**${call.name}**`).filter((name, index, self) => self.indexOf(name) === index).join(", ");
+        const beforeMainContent = toolCalls.map((call, index) => (0, import_react5.createElement)(ToolCallsInfo2, { key: index, call, index }));
+        if (autoApproved) {
+          const content2 = `Auto-approved ${toolCalls.length} tool ${isMultiple ? "calls" : "call"}: ${toolNames}`;
+          return this.createBotMessage(content2, { beforeMainContent });
+        }
+        const content = `${BOT_NAME} wants to use ${isMultiple ? "tools" : "a tool"}: ${toolNames}`;
+        const botMessage = this.createBotMessage(content);
+        botMessage.extraContent = {
+          beforeMainContent,
+          afterMainContent: (0, import_react5.createElement)(ToolCallsApprove2, { toolCalls, messageId: botMessage.id })
         };
-        return aiService.createBotMessage(content, extraContent);
+        return botMessage;
       }
     };
     aiService = new AiService();
   }
 });
 
-// src/ai-plugin/common/ai-preferences-service.ts
-var STORAGE_KEY_PREFERENCES, DEFAULT_OPTIONS, AiPreferencesService, aiPreferencesService;
-var init_ai_preferences_service = __esm({
-  "src/ai-plugin/common/ai-preferences-service.ts"() {
+// src/ai-plugin/chat/model.ts
+var ChatbotDialog;
+var init_model = __esm({
+  "src/ai-plugin/chat/model.ts"() {
     "use strict";
-    init_ai_model();
-    init_ai_service();
-    STORAGE_KEY_PREFERENCES = "ai.preferences";
-    DEFAULT_OPTIONS = {
-      model: MODELS[0]
-    };
-    AiPreferencesService = class {
-      loadOptions() {
-        const item = localStorage.getItem(STORAGE_KEY_PREFERENCES);
-        const savedOptions = item ? JSON.parse(item) : {};
-        return { ...DEFAULT_OPTIONS, ...savedOptions };
+    ChatbotDialog = class {
+      constructor(messages, summary) {
+        this.messages = messages;
+        this.summary = summary;
+        this.id = messages[0]?.id ?? "";
       }
-      saveOptions(options) {
-        const updated = { ...this.loadOptions(), ...options };
-        localStorage.setItem(STORAGE_KEY_PREFERENCES, JSON.stringify(updated));
-        if (options.model) {
-          aiService.reset(options.model);
+      messages;
+      summary;
+      id;
+      setMessages(messages) {
+        if (messages[0]?.id !== this.id) {
+          throw new Error("Not the same dialog");
         }
+        this.messages = [...messages];
+      }
+      createConversation() {
+        const text = this.summary ?? (this.messages[0]?.content ?? "").substring(0, 20);
+        return { id: this.id, text };
       }
     };
-    aiPreferencesService = new AiPreferencesService();
   }
 });
 
-// node_modules/react-is/cjs/react-is.production.min.js
-var require_react_is_production_min = __commonJS({
-  "node_modules/react-is/cjs/react-is.production.min.js"(exports2) {
-    "use strict";
-    var b = "function" === typeof Symbol && Symbol.for;
-    var c = b ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
-    var d = b ? /* @__PURE__ */ Symbol.for("react.portal") : 60106;
-    var e = b ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107;
-    var f = b ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108;
-    var g = b ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114;
-    var h = b ? /* @__PURE__ */ Symbol.for("react.provider") : 60109;
-    var k = b ? /* @__PURE__ */ Symbol.for("react.context") : 60110;
-    var l = b ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111;
-    var m = b ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111;
-    var n = b ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112;
-    var p = b ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113;
-    var q = b ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120;
-    var r = b ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
-    var t = b ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116;
-    var v = b ? /* @__PURE__ */ Symbol.for("react.block") : 60121;
-    var w = b ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117;
-    var x = b ? /* @__PURE__ */ Symbol.for("react.responder") : 60118;
-    var y = b ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
-    function z(a) {
-      if ("object" === typeof a && null !== a) {
-        var u = a.$$typeof;
-        switch (u) {
-          case c:
-            switch (a = a.type, a) {
-              case l:
-              case m:
-              case e:
-              case g:
-              case f:
-              case p:
-                return a;
-              default:
-                switch (a = a && a.$$typeof, a) {
-                  case k:
-                  case n:
-                  case t:
-                  case r:
-                  case h:
-                    return a;
-                  default:
-                    return u;
-                }
-            }
-          case d:
-            return u;
-        }
-      }
+// src/ai-plugin/chat/context.ts
+function useChatbot() {
+  const [messages, setMessages] = (0, import_react6.useState)([]);
+  const [dialogs, setDialogs] = (0, import_react6.useState)([]);
+  const [conversations, setConversations] = (0, import_react6.useState)([]);
+  const [announcement, setAnnouncement] = (0, import_react6.useState)("");
+  const [isChatbotOpen, setIsChatbotOpen] = (0, import_react6.useState)(false);
+  const [isSendButtonDisabled, setIsSendButtonDisabled] = (0, import_react6.useState)(false);
+  const updateConversations = (messages2, summary) => {
+    const dialogId = messages2[0]?.id;
+    if (!dialogId) {
+      return;
     }
-    function A(a) {
-      return z(a) === m;
+    setMessages(messages2);
+    let dialog = dialogs.find((d) => d.id === dialogId);
+    if (dialog) {
+      dialog.setMessages(messages2);
+    } else {
+      dialog = new ChatbotDialog(messages2, summary);
+      dialogs.push(dialog);
     }
-    exports2.AsyncMode = l;
-    exports2.ConcurrentMode = m;
-    exports2.ContextConsumer = k;
-    exports2.ContextProvider = h;
-    exports2.Element = c;
-    exports2.ForwardRef = n;
-    exports2.Fragment = e;
-    exports2.Lazy = t;
-    exports2.Memo = r;
-    exports2.Portal = d;
-    exports2.Profiler = g;
-    exports2.StrictMode = f;
-    exports2.Suspense = p;
-    exports2.isAsyncMode = function(a) {
-      return A(a) || z(a) === l;
-    };
-    exports2.isConcurrentMode = A;
-    exports2.isContextConsumer = function(a) {
-      return z(a) === k;
-    };
-    exports2.isContextProvider = function(a) {
-      return z(a) === h;
-    };
-    exports2.isElement = function(a) {
-      return "object" === typeof a && null !== a && a.$$typeof === c;
-    };
-    exports2.isForwardRef = function(a) {
-      return z(a) === n;
-    };
-    exports2.isFragment = function(a) {
-      return z(a) === e;
-    };
-    exports2.isLazy = function(a) {
-      return z(a) === t;
-    };
-    exports2.isMemo = function(a) {
-      return z(a) === r;
-    };
-    exports2.isPortal = function(a) {
-      return z(a) === d;
-    };
-    exports2.isProfiler = function(a) {
-      return z(a) === g;
-    };
-    exports2.isStrictMode = function(a) {
-      return z(a) === f;
-    };
-    exports2.isSuspense = function(a) {
-      return z(a) === p;
-    };
-    exports2.isValidElementType = function(a) {
-      return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
-    };
-    exports2.typeOf = z;
+    setDialogs([...dialogs]);
+    log.debug("Updated dialogs:", dialogs);
+    if (!conversations.some((c) => c.id === dialogId)) {
+      const conversation = dialog.createConversation();
+      conversations.push(conversation);
+      setConversations([...conversations]);
+      log.debug("Updated conversations:", conversations);
+    }
+  };
+  return {
+    messages,
+    setMessages,
+    dialogs,
+    setDialogs,
+    conversations,
+    setConversations,
+    announcement,
+    setAnnouncement,
+    isChatbotOpen,
+    setIsChatbotOpen,
+    isSendButtonDisabled,
+    setIsSendButtonDisabled,
+    updateConversations
+  };
+}
+var import_react6, ChatbotContext;
+var init_context = __esm({
+  "src/ai-plugin/chat/context.ts"() {
+    "use strict";
+    import_react6 = require("react");
+    init_globals();
+    init_model();
+    ChatbotContext = (0, import_react6.createContext)({
+      messages: [],
+      setMessages: () => {
+      },
+      dialogs: [],
+      setDialogs: () => {
+      },
+      conversations: [],
+      setConversations: () => {
+      },
+      announcement: "",
+      setAnnouncement: () => {
+      },
+      isChatbotOpen: false,
+      setIsChatbotOpen: () => {
+      },
+      isSendButtonDisabled: false,
+      setIsSendButtonDisabled: () => {
+      },
+      updateConversations: () => {
+      }
+    });
   }
 });
 
-// node_modules/react-is/cjs/react-is.development.js
-var require_react_is_development = __commonJS({
-  "node_modules/react-is/cjs/react-is.development.js"(exports2) {
+// src/ai-plugin/chat/ThinkInfo.tsx
+var import_MarkdownContent, import_react_core, import_jsx_runtime, ThinkInfo;
+var init_ThinkInfo = __esm({
+  "src/ai-plugin/chat/ThinkInfo.tsx"() {
     "use strict";
-    if (process.env.NODE_ENV !== "production") {
-      (function() {
-        "use strict";
-        var hasSymbol = typeof Symbol === "function" && Symbol.for;
-        var REACT_ELEMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
-        var REACT_PORTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.portal") : 60106;
-        var REACT_FRAGMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107;
-        var REACT_STRICT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108;
-        var REACT_PROFILER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114;
-        var REACT_PROVIDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.provider") : 60109;
-        var REACT_CONTEXT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.context") : 60110;
-        var REACT_ASYNC_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111;
-        var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111;
-        var REACT_FORWARD_REF_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112;
-        var REACT_SUSPENSE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113;
-        var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120;
-        var REACT_MEMO_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
-        var REACT_LAZY_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116;
-        var REACT_BLOCK_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.block") : 60121;
-        var REACT_FUNDAMENTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117;
-        var REACT_RESPONDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.responder") : 60118;
-        var REACT_SCOPE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
-        function isValidElementType(type) {
-          return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
-          type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
-        }
-        function typeOf(object) {
-          if (typeof object === "object" && object !== null) {
-            var $$typeof = object.$$typeof;
-            switch ($$typeof) {
-              case REACT_ELEMENT_TYPE:
-                var type = object.type;
-                switch (type) {
-                  case REACT_ASYNC_MODE_TYPE:
-                  case REACT_CONCURRENT_MODE_TYPE:
-                  case REACT_FRAGMENT_TYPE:
-                  case REACT_PROFILER_TYPE:
-                  case REACT_STRICT_MODE_TYPE:
-                  case REACT_SUSPENSE_TYPE:
-                    return type;
-                  default:
-                    var $$typeofType = type && type.$$typeof;
-                    switch ($$typeofType) {
-                      case REACT_CONTEXT_TYPE:
-                      case REACT_FORWARD_REF_TYPE:
-                      case REACT_LAZY_TYPE:
-                      case REACT_MEMO_TYPE:
-                      case REACT_PROVIDER_TYPE:
-                        return $$typeofType;
-                      default:
-                        return $$typeof;
-                    }
-                }
-              case REACT_PORTAL_TYPE:
-                return $$typeof;
-            }
-          }
-          return void 0;
-        }
-        var AsyncMode = REACT_ASYNC_MODE_TYPE;
-        var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
-        var ContextConsumer = REACT_CONTEXT_TYPE;
-        var ContextProvider = REACT_PROVIDER_TYPE;
-        var Element = REACT_ELEMENT_TYPE;
-        var ForwardRef = REACT_FORWARD_REF_TYPE;
-        var Fragment2 = REACT_FRAGMENT_TYPE;
-        var Lazy = REACT_LAZY_TYPE;
-        var Memo = REACT_MEMO_TYPE;
-        var Portal = REACT_PORTAL_TYPE;
-        var Profiler = REACT_PROFILER_TYPE;
-        var StrictMode = REACT_STRICT_MODE_TYPE;
-        var Suspense = REACT_SUSPENSE_TYPE;
-        var hasWarnedAboutDeprecatedIsAsyncMode = false;
-        function isAsyncMode(object) {
-          {
-            if (!hasWarnedAboutDeprecatedIsAsyncMode) {
-              hasWarnedAboutDeprecatedIsAsyncMode = true;
-              console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
-            }
-          }
-          return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
-        }
-        function isConcurrentMode(object) {
-          return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
-        }
-        function isContextConsumer(object) {
-          return typeOf(object) === REACT_CONTEXT_TYPE;
-        }
-        function isContextProvider(object) {
-          return typeOf(object) === REACT_PROVIDER_TYPE;
-        }
-        function isElement(object) {
-          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
-        }
-        function isForwardRef(object) {
-          return typeOf(object) === REACT_FORWARD_REF_TYPE;
-        }
-        function isFragment(object) {
-          return typeOf(object) === REACT_FRAGMENT_TYPE;
-        }
-        function isLazy(object) {
-          return typeOf(object) === REACT_LAZY_TYPE;
-        }
-        function isMemo(object) {
-          return typeOf(object) === REACT_MEMO_TYPE;
-        }
-        function isPortal(object) {
-          return typeOf(object) === REACT_PORTAL_TYPE;
-        }
-        function isProfiler(object) {
-          return typeOf(object) === REACT_PROFILER_TYPE;
-        }
-        function isStrictMode(object) {
-          return typeOf(object) === REACT_STRICT_MODE_TYPE;
-        }
-        function isSuspense(object) {
-          return typeOf(object) === REACT_SUSPENSE_TYPE;
-        }
-        exports2.AsyncMode = AsyncMode;
-        exports2.ConcurrentMode = ConcurrentMode;
-        exports2.ContextConsumer = ContextConsumer;
-        exports2.ContextProvider = ContextProvider;
-        exports2.Element = Element;
-        exports2.ForwardRef = ForwardRef;
-        exports2.Fragment = Fragment2;
-        exports2.Lazy = Lazy;
-        exports2.Memo = Memo;
-        exports2.Portal = Portal;
-        exports2.Profiler = Profiler;
-        exports2.StrictMode = StrictMode;
-        exports2.Suspense = Suspense;
-        exports2.isAsyncMode = isAsyncMode;
-        exports2.isConcurrentMode = isConcurrentMode;
-        exports2.isContextConsumer = isContextConsumer;
-        exports2.isContextProvider = isContextProvider;
-        exports2.isElement = isElement;
-        exports2.isForwardRef = isForwardRef;
-        exports2.isFragment = isFragment;
-        exports2.isLazy = isLazy;
-        exports2.isMemo = isMemo;
-        exports2.isPortal = isPortal;
-        exports2.isProfiler = isProfiler;
-        exports2.isStrictMode = isStrictMode;
-        exports2.isSuspense = isSuspense;
-        exports2.isValidElementType = isValidElementType;
-        exports2.typeOf = typeOf;
-      })();
-    }
+    import_MarkdownContent = __toESM(require("@patternfly/chatbot/dist/dynamic/MarkdownContent"));
+    import_react_core = require("@patternfly/react-core");
+    import_jsx_runtime = require("react/jsx-runtime");
+    ThinkInfo = ({ think }) => {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.Alert, { variant: "info", title: "Thinking", isExpandable: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_MarkdownContent.default, { content: think }) });
+    };
   }
 });
 
-// node_modules/react-is/index.js
-var require_react_is = __commonJS({
-  "node_modules/react-is/index.js"(exports2, module2) {
+// src/ai-plugin/chat/ToolCallsInfo.tsx
+var import_react_core2, import_wrench_icon, import_jsx_runtime2, ToolCallsInfo;
+var init_ToolCallsInfo = __esm({
+  "src/ai-plugin/chat/ToolCallsInfo.tsx"() {
     "use strict";
-    if (process.env.NODE_ENV === "production") {
-      module2.exports = require_react_is_production_min();
-    } else {
-      module2.exports = require_react_is_development();
-    }
+    import_react_core2 = require("@patternfly/react-core");
+    import_wrench_icon = __toESM(require("@patternfly/react-icons/dist/esm/icons/wrench-icon"));
+    import_jsx_runtime2 = require("react/jsx-runtime");
+    ToolCallsInfo = ({ call, index }) => {
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_core2.Alert, { variant: "info", customIcon: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_wrench_icon.default, {}), title: call.name, isInline: true, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
+        "Args: ",
+        JSON.stringify(call.args)
+      ] }) }, index);
+    };
   }
 });
 
-// node_modules/object-assign/index.js
-var require_object_assign = __commonJS({
-  "node_modules/object-assign/index.js"(exports2, module2) {
+// src/ai-plugin/chat/ToolCallsApprove.tsx
+var import_ui, import_react_core3, import_react7, import_jsx_runtime3, ToolCallsApprove;
+var init_ToolCallsApprove = __esm({
+  "src/ai-plugin/chat/ToolCallsApprove.tsx"() {
     "use strict";
-    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-    function toObject(val) {
-      if (val === null || val === void 0) {
-        throw new TypeError("Object.assign cannot be called with null or undefined");
-      }
-      return Object(val);
-    }
-    function shouldUseNative() {
-      try {
-        if (!Object.assign) {
-          return false;
-        }
-        var test1 = new String("abc");
-        test1[5] = "de";
-        if (Object.getOwnPropertyNames(test1)[0] === "5") {
-          return false;
-        }
-        var test2 = {};
-        for (var i = 0; i < 10; i++) {
-          test2["_" + String.fromCharCode(i)] = i;
-        }
-        var order22 = Object.getOwnPropertyNames(test2).map(function(n) {
-          return test2[n];
-        });
-        if (order22.join("") !== "0123456789") {
-          return false;
-        }
-        var test3 = {};
-        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
-          test3[letter] = letter;
+    import_ui = require("@hawtio/react/ui");
+    import_react_core3 = require("@patternfly/react-core");
+    import_react7 = require("react");
+    init_ai_service();
+    init_context();
+    init_globals();
+    init_ThinkInfo();
+    init_ToolCallsInfo();
+    import_jsx_runtime3 = require("react/jsx-runtime");
+    ToolCallsApprove = ({ toolCalls, messageId }) => {
+      const { username } = (0, import_react7.useContext)(import_ui.PageContext);
+      const { messages, setAnnouncement, setIsSendButtonDisabled, updateConversations } = (0, import_react7.useContext)(ChatbotContext);
+      const messagesRef = (0, import_react7.useRef)(messages);
+      (0, import_react7.useEffect)(() => {
+        messagesRef.current = messages;
+      }, [messages]);
+      const removeApproveButtons = (messages2) => {
+        return messages2.map(
+          (m) => m.id === messageId ? { ...m, extraContent: { ...m.extraContent, afterMainContent: void 0 } } : m
+        );
+      };
+      const approve = async (toolCalls2) => {
+        log.debug("ToolCallsApprove - Approved", messagesRef.current);
+        setIsSendButtonDisabled(true);
+        const newMessages = removeApproveButtons([...messagesRef.current]);
+        newMessages.push(aiService.createUserMessage(username, "Approved"));
+        newMessages.push(aiService.createLoadingBotMessage());
+        updateConversations(newMessages);
+        setAnnouncement(`User approved tool usage. Message from Bot is loading.`);
+        const dialogId = newMessages[0].id;
+        const loadedMessages = [...newMessages];
+        const answer = await aiService.invokeTools(dialogId, toolCalls2, (intermediateAnswer) => {
+          loadedMessages.pop();
+          loadedMessages.push(aiService.toBotMessage(intermediateAnswer, true, ThinkInfo, ToolCallsInfo, ToolCallsApprove));
+          loadedMessages.push(aiService.createLoadingBotMessage());
+          updateConversations([...loadedMessages]);
         });
-        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
-          return false;
-        }
-        return true;
-      } catch (err) {
-        return false;
-      }
-    }
-    module2.exports = shouldUseNative() ? Object.assign : function(target, source) {
-      var from;
-      var to = toObject(target);
-      var symbols;
-      for (var s = 1; s < arguments.length; s++) {
-        from = Object(arguments[s]);
-        for (var key in from) {
-          if (hasOwnProperty.call(from, key)) {
-            to[key] = from[key];
-          }
+        loadedMessages.pop();
+        const botMessage = aiService.toBotMessage(answer, false, ThinkInfo, ToolCallsInfo, ToolCallsApprove);
+        loadedMessages.push(botMessage);
+        updateConversations([...loadedMessages]);
+        setAnnouncement(`Message from Bot: ${answer}`);
+        if (!aiService.hasToolCalls(answer)) {
+          setIsSendButtonDisabled(false);
         }
-        if (getOwnPropertySymbols) {
-          symbols = getOwnPropertySymbols(from);
-          for (var i = 0; i < symbols.length; i++) {
-            if (propIsEnumerable.call(from, symbols[i])) {
-              to[symbols[i]] = from[symbols[i]];
-            }
-          }
+      };
+      const reject = () => {
+        log.debug("ToolCallsApprove - Rejected", messagesRef.current);
+        const currentMessages = messagesRef.current;
+        const dialogId = currentMessages[0]?.id;
+        if (dialogId) {
+          aiService.rejectTools(dialogId, toolCalls);
         }
-      }
-      return to;
+        const newMessages = removeApproveButtons([...currentMessages]);
+        newMessages.push(aiService.createUserMessage(username, "Rejected"));
+        updateConversations(newMessages);
+        setIsSendButtonDisabled(false);
+      };
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_core3.Flex, { columnGap: { default: "columnGapSm" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_core3.Button, { variant: "primary", onClick: () => approve(toolCalls), children: "Approve" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_core3.Button, { variant: "secondary", onClick: reject, children: "Reject" })
+      ] });
     };
   }
 });
 
-// node_modules/prop-types/lib/ReactPropTypesSecret.js
-var require_ReactPropTypesSecret = __commonJS({
-  "node_modules/prop-types/lib/ReactPropTypesSecret.js"(exports2, module2) {
-    "use strict";
-    var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
-    module2.exports = ReactPropTypesSecret;
-  }
-});
-
-// node_modules/prop-types/lib/has.js
-var require_has = __commonJS({
-  "node_modules/prop-types/lib/has.js"(exports2, module2) {
-    "use strict";
-    module2.exports = Function.call.bind(Object.prototype.hasOwnProperty);
-  }
-});
-
-// node_modules/prop-types/checkPropTypes.js
-var require_checkPropTypes = __commonJS({
-  "node_modules/prop-types/checkPropTypes.js"(exports2, module2) {
+// src/ai-plugin/chat/ChatbotPanel.tsx
+var import_ui2, import_Chatbot, import_ChatbotContent, import_ChatbotConversationHistoryNav, import_ChatbotFooter, import_ChatbotHeader, import_ChatbotWelcomePrompt, import_Message, import_MessageBar, import_MessageBox, import_react_core4, import_react8, import_jsx_runtime4, ChatbotPanel, ChatbotPanelHeader, ChatbotPanelContent, ChatbotPanelFooter;
+var init_ChatbotPanel = __esm({
+  "src/ai-plugin/chat/ChatbotPanel.tsx"() {
     "use strict";
-    var printWarning = function() {
-    };
-    if (process.env.NODE_ENV !== "production") {
-      ReactPropTypesSecret = require_ReactPropTypesSecret();
-      loggedTypeFailures = {};
-      has = require_has();
-      printWarning = function(text) {
-        var message = "Warning: " + text;
-        if (typeof console !== "undefined") {
-          console.error(message);
+    import_ui2 = require("@hawtio/react/ui");
+    import_Chatbot = __toESM(require("@patternfly/chatbot/dist/dynamic/Chatbot"));
+    import_ChatbotContent = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotContent"));
+    import_ChatbotConversationHistoryNav = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotConversationHistoryNav"));
+    import_ChatbotFooter = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotFooter"));
+    import_ChatbotHeader = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotHeader"));
+    import_ChatbotWelcomePrompt = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotWelcomePrompt"));
+    import_Message = __toESM(require("@patternfly/chatbot/dist/dynamic/Message"));
+    import_MessageBar = __toESM(require("@patternfly/chatbot/dist/dynamic/MessageBar"));
+    import_MessageBox = __toESM(require("@patternfly/chatbot/dist/dynamic/MessageBox"));
+    import_react_core4 = require("@patternfly/react-core");
+    import_react8 = __toESM(require("react"));
+    init_ai_service();
+    init_context();
+    init_globals();
+    init_ThinkInfo();
+    init_ToolCallsApprove();
+    init_ToolCallsInfo();
+    import_jsx_runtime4 = require("react/jsx-runtime");
+    ChatbotPanel = ({ title, displayMode }) => {
+      const { setMessages, dialogs, conversations } = (0, import_react8.useContext)(ChatbotContext);
+      const [isDrawerOpen, setIsDrawerOpen] = (0, import_react8.useState)(false);
+      const [filteredConversations, setFilteredConversations] = (0, import_react8.useState)(conversations);
+      const onSelectItemInHistory = (selected) => {
+        log.debug("Selected conversation with ID:", selected);
+        const dialog = dialogs.find((c) => c.id === selected);
+        if (dialog) {
+          setMessages(dialog.messages);
+          setIsDrawerOpen(false);
         }
-        try {
-          throw new Error(message);
-        } catch (x) {
+      };
+      const handleSearchTextChange = (value) => {
+        if (value.trim() === "") {
+          setFilteredConversations(conversations);
+          return;
         }
+        const filtered = conversations.filter((c) => c.text.toLowerCase().includes(value.toLowerCase()));
+        log.debug("Filtered conversations:", filtered);
+        setFilteredConversations(filtered);
       };
-    }
-    var ReactPropTypesSecret;
-    var loggedTypeFailures;
-    var has;
-    function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
-      if (process.env.NODE_ENV !== "production") {
-        for (var typeSpecName in typeSpecs) {
-          if (has(typeSpecs, typeSpecName)) {
-            var error;
-            try {
-              if (typeof typeSpecs[typeSpecName] !== "function") {
-                var err = Error(
-                  (componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
-                );
-                err.name = "Invariant Violation";
-                throw err;
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_Chatbot.default, { isCompact: true, displayMode, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        import_ChatbotConversationHistoryNav.default,
+        {
+          isCompact: true,
+          drawerPanelContentProps: { isResizable: true, minSize: "200px" },
+          displayMode,
+          onDrawerToggle: () => {
+            setIsDrawerOpen(!isDrawerOpen);
+            setFilteredConversations(conversations);
+          },
+          isDrawerOpen,
+          setIsDrawerOpen,
+          onSelectActiveItem: (_e, selectedItem) => onSelectItemInHistory(String(selectedItem)),
+          conversations: [...filteredConversations].reverse(),
+          onNewChat: () => {
+            setIsDrawerOpen(false);
+            setFilteredConversations(conversations);
+            setMessages([]);
+          },
+          handleTextInputChange: handleSearchTextChange,
+          drawerContent: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              ChatbotPanelHeader,
+              {
+                isDrawerOpen,
+                setIsDrawerOpen,
+                title,
+                hasCloseButton: displayMode === import_Chatbot.ChatbotDisplayMode.drawer
               }
-              error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
-            } catch (ex) {
-              error = ex;
-            }
-            if (error && !(error instanceof Error)) {
-              printWarning(
-                (componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
-              );
-            }
-            if (error instanceof Error && !(error.message in loggedTypeFailures)) {
-              loggedTypeFailures[error.message] = true;
-              var stack = getStack ? getStack() : "";
-              printWarning(
-                "Failed " + location + " type: " + error.message + (stack != null ? stack : "")
-              );
-            }
-          }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ChatbotPanelContent, {}),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ChatbotPanelFooter, {})
+          ] })
         }
-      }
-    }
-    checkPropTypes.resetWarningCache = function() {
-      if (process.env.NODE_ENV !== "production") {
-        loggedTypeFailures = {};
-      }
+      ) });
     };
-    module2.exports = checkPropTypes;
-  }
-});
-
-// node_modules/prop-types/factoryWithTypeCheckers.js
-var require_factoryWithTypeCheckers = __commonJS({
-  "node_modules/prop-types/factoryWithTypeCheckers.js"(exports2, module2) {
-    "use strict";
-    var ReactIs = require_react_is();
-    var assign = require_object_assign();
-    var ReactPropTypesSecret = require_ReactPropTypesSecret();
-    var has = require_has();
-    var checkPropTypes = require_checkPropTypes();
-    var printWarning = function() {
+    ChatbotPanelHeader = ({ isDrawerOpen, setIsDrawerOpen, title, hasCloseButton }) => {
+      const { setIsChatbotOpen } = (0, import_react8.useContext)(ChatbotContext);
+      const modelName = aiService.getModel()?.name;
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ChatbotHeader.default, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ChatbotHeader.ChatbotHeaderMain, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ChatbotHeader.ChatbotHeaderMenu, { "aria-expanded": isDrawerOpen, onMenuToggle: () => setIsDrawerOpen(!isDrawerOpen) }),
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ChatbotHeader.ChatbotHeaderTitle, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.Content, { component: "h2", children: title }) })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ChatbotHeader.ChatbotHeaderActions, { children: [
+          modelName && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.Label, { variant: "outline", children: modelName }),
+          hasCloseButton && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ChatbotHeader.ChatbotHeaderCloseButton, { onClick: () => setIsChatbotOpen(false) })
+        ] })
+      ] });
     };
-    if (process.env.NODE_ENV !== "production") {
-      printWarning = function(text) {
-        var message = "Warning: " + text;
-        if (typeof console !== "undefined") {
-          console.error(message);
+    ChatbotPanelContent = () => {
+      const { messages, announcement } = (0, import_react8.useContext)(ChatbotContext);
+      const { username } = (0, import_react8.useContext)(import_ui2.PageContext);
+      const scrollToBottomRef = (0, import_react8.useRef)(null);
+      const welcomeTitle = `Hello, ${username}!`;
+      const welcomeDescription = "How can I help you manage or diagnose your Java application?";
+      (0, import_react8.useEffect)(() => {
+        if (messages.length > 2) {
+          scrollToBottomRef.current?.scrollIntoView({ behavior: "smooth" });
         }
-        try {
-          throw new Error(message);
-        } catch (x) {
+      }, [messages]);
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ChatbotContent.default, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_MessageBox.default, { announcement, children: [
+        messages.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ChatbotWelcomePrompt.default, { title: welcomeTitle, description: welcomeDescription }),
+        messages.map((message, index) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react8.default.Fragment, { children: [
+          index === messages.length - 1 && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { ref: scrollToBottomRef }),
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_Message.default, { ...message }, message.id)
+        ] }, message.id))
+      ] }) });
+    };
+    ChatbotPanelFooter = () => {
+      const { username } = (0, import_react8.useContext)(import_ui2.PageContext);
+      const { messages, setAnnouncement, isSendButtonDisabled, setIsSendButtonDisabled, updateConversations } = (0, import_react8.useContext)(ChatbotContext);
+      const messagesRef = (0, import_react8.useRef)(messages);
+      (0, import_react8.useEffect)(() => {
+        messagesRef.current = messages;
+      }, [messages]);
+      const handleSend = async (message) => {
+        if (!message.trim()) {
+          return;
         }
-      };
-    }
-    function emptyFunctionThatReturnsNull() {
-      return null;
-    }
-    module2.exports = function(isValidElement, throwOnDirectAccess) {
-      var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
-      var FAUX_ITERATOR_SYMBOL = "@@iterator";
-      function getIteratorFn(maybeIterable) {
-        var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
-        if (typeof iteratorFn === "function") {
-          return iteratorFn;
+        log.debug("Send", messagesRef.current);
+        setIsSendButtonDisabled(true);
+        const newMessages = [];
+        newMessages.push(...messagesRef.current);
+        newMessages.push(aiService.createUserMessage(username, message));
+        newMessages.push(aiService.createLoadingBotMessage());
+        updateConversations(newMessages);
+        setAnnouncement(`Message from User: ${message}. Message from Bot is loading.`);
+        log.debug("handleSend - new messages:", newMessages);
+        const dialogId = newMessages[0].id;
+        const loadedMessages = [...newMessages];
+        const onMessage = (intermediateAnswer) => {
+          loadedMessages.pop();
+          loadedMessages.push(aiService.toBotMessage(intermediateAnswer, true, ThinkInfo, ToolCallsInfo, ToolCallsApprove));
+          loadedMessages.push(aiService.createLoadingBotMessage());
+          updateConversations([...loadedMessages]);
+        };
+        const answer = await (newMessages.length === 2 ? aiService.newChat(dialogId, { message }, onMessage) : aiService.chat(dialogId, message, onMessage));
+        log.debug("handleSend - loaded messages:", loadedMessages);
+        loadedMessages.pop();
+        const botMessage = aiService.toBotMessage(answer, false, ThinkInfo, ToolCallsInfo, ToolCallsApprove);
+        loadedMessages.push(botMessage);
+        updateConversations([...loadedMessages]);
+        setAnnouncement(`Message from Bot: ${answer}`);
+        if (!aiService.hasToolCalls(answer)) {
+          setIsSendButtonDisabled(false);
         }
-      }
-      var ANONYMOUS = "<<anonymous>>";
-      var ReactPropTypes = {
-        array: createPrimitiveTypeChecker("array"),
-        bigint: createPrimitiveTypeChecker("bigint"),
-        bool: createPrimitiveTypeChecker("boolean"),
-        func: createPrimitiveTypeChecker("function"),
-        number: createPrimitiveTypeChecker("number"),
-        object: createPrimitiveTypeChecker("object"),
-        string: createPrimitiveTypeChecker("string"),
-        symbol: createPrimitiveTypeChecker("symbol"),
-        any: createAnyTypeChecker(),
-        arrayOf: createArrayOfTypeChecker,
-        element: createElementTypeChecker(),
-        elementType: createElementTypeTypeChecker(),
-        instanceOf: createInstanceTypeChecker,
-        node: createNodeChecker(),
-        objectOf: createObjectOfTypeChecker,
-        oneOf: createEnumTypeChecker,
-        oneOfType: createUnionTypeChecker,
-        shape: createShapeTypeChecker,
-        exact: createStrictShapeTypeChecker
       };
-      function is(x, y) {
-        if (x === y) {
-          return x !== 0 || 1 / x === 1 / y;
-        } else {
-          return x !== x && y !== y;
-        }
-      }
-      function PropTypeError(message, data) {
-        this.message = message;
-        this.data = data && typeof data === "object" ? data : {};
-        this.stack = "";
-      }
-      PropTypeError.prototype = Error.prototype;
-      function createChainableTypeChecker(validate) {
-        if (process.env.NODE_ENV !== "production") {
-          var manualPropTypeCallCache = {};
-          var manualPropTypeWarningCount = 0;
-        }
-        function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
-          componentName = componentName || ANONYMOUS;
-          propFullName = propFullName || propName;
-          if (secret !== ReactPropTypesSecret) {
-            if (throwOnDirectAccess) {
-              var err = new Error(
-                "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
-              );
-              err.name = "Invariant Violation";
-              throw err;
-            } else if (process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
-              var cacheKey = componentName + ":" + propName;
-              if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
-              manualPropTypeWarningCount < 3) {
-                printWarning(
-                  "You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
-                );
-                manualPropTypeCallCache[cacheKey] = true;
-                manualPropTypeWarningCount++;
-              }
-            }
-          }
-          if (props[propName] == null) {
-            if (isRequired) {
-              if (props[propName] === null) {
-                return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`."));
-              }
-              return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`."));
-            }
-            return null;
-          } else {
-            return validate(props, propName, componentName, location, propFullName);
-          }
-        }
-        var chainedCheckType = checkType.bind(null, false);
-        chainedCheckType.isRequired = checkType.bind(null, true);
-        return chainedCheckType;
-      }
-      function createPrimitiveTypeChecker(expectedType) {
-        function validate(props, propName, componentName, location, propFullName, secret) {
-          var propValue = props[propName];
-          var propType = getPropType(propValue);
-          if (propType !== expectedType) {
-            var preciseType = getPreciseType(propValue);
-            return new PropTypeError(
-              "Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`."),
-              { expectedType }
-            );
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createAnyTypeChecker() {
-        return createChainableTypeChecker(emptyFunctionThatReturnsNull);
-      }
-      function createArrayOfTypeChecker(typeChecker) {
-        function validate(props, propName, componentName, location, propFullName) {
-          if (typeof typeChecker !== "function") {
-            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
-          }
-          var propValue = props[propName];
-          if (!Array.isArray(propValue)) {
-            var propType = getPropType(propValue);
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array."));
-          }
-          for (var i = 0; i < propValue.length; i++) {
-            var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
-            if (error instanceof Error) {
-              return error;
-            }
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createElementTypeChecker() {
-        function validate(props, propName, componentName, location, propFullName) {
-          var propValue = props[propName];
-          if (!isValidElement(propValue)) {
-            var propType = getPropType(propValue);
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement."));
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createElementTypeTypeChecker() {
-        function validate(props, propName, componentName, location, propFullName) {
-          var propValue = props[propName];
-          if (!ReactIs.isValidElementType(propValue)) {
-            var propType = getPropType(propValue);
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createInstanceTypeChecker(expectedClass) {
-        function validate(props, propName, componentName, location, propFullName) {
-          if (!(props[propName] instanceof expectedClass)) {
-            var expectedClassName = expectedClass.name || ANONYMOUS;
-            var actualClassName = getClassName(props[propName]);
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createEnumTypeChecker(expectedValues) {
-        if (!Array.isArray(expectedValues)) {
-          if (process.env.NODE_ENV !== "production") {
-            if (arguments.length > 1) {
-              printWarning(
-                "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
-              );
-            } else {
-              printWarning("Invalid argument supplied to oneOf, expected an array.");
-            }
-          }
-          return emptyFunctionThatReturnsNull;
-        }
-        function validate(props, propName, componentName, location, propFullName) {
-          var propValue = props[propName];
-          for (var i = 0; i < expectedValues.length; i++) {
-            if (is(propValue, expectedValues[i])) {
-              return null;
-            }
-          }
-          var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
-            var type = getPreciseType(value);
-            if (type === "symbol") {
-              return String(value);
-            }
-            return value;
-          });
-          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + "."));
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createObjectOfTypeChecker(typeChecker) {
-        function validate(props, propName, componentName, location, propFullName) {
-          if (typeof typeChecker !== "function") {
-            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
-          }
-          var propValue = props[propName];
-          var propType = getPropType(propValue);
-          if (propType !== "object") {
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object."));
-          }
-          for (var key in propValue) {
-            if (has(propValue, key)) {
-              var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
-              if (error instanceof Error) {
-                return error;
-              }
-            }
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createUnionTypeChecker(arrayOfTypeCheckers) {
-        if (!Array.isArray(arrayOfTypeCheckers)) {
-          process.env.NODE_ENV !== "production" ? printWarning("Invalid argument supplied to oneOfType, expected an instance of array.") : void 0;
-          return emptyFunctionThatReturnsNull;
-        }
-        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
-          var checker = arrayOfTypeCheckers[i];
-          if (typeof checker !== "function") {
-            printWarning(
-              "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."
-            );
-            return emptyFunctionThatReturnsNull;
-          }
-        }
-        function validate(props, propName, componentName, location, propFullName) {
-          var expectedTypes = [];
-          for (var i2 = 0; i2 < arrayOfTypeCheckers.length; i2++) {
-            var checker2 = arrayOfTypeCheckers[i2];
-            var checkerResult = checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
-            if (checkerResult == null) {
-              return null;
-            }
-            if (checkerResult.data && has(checkerResult.data, "expectedType")) {
-              expectedTypes.push(checkerResult.data.expectedType);
-            }
-          }
-          var expectedTypesMessage = expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "";
-          return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`" + expectedTypesMessage + "."));
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createNodeChecker() {
-        function validate(props, propName, componentName, location, propFullName) {
-          if (!isNode(props[propName])) {
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode."));
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function invalidValidatorError(componentName, location, propFullName, key, type) {
-        return new PropTypeError(
-          (componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + "`."
-        );
-      }
-      function createShapeTypeChecker(shapeTypes) {
-        function validate(props, propName, componentName, location, propFullName) {
-          var propValue = props[propName];
-          var propType = getPropType(propValue);
-          if (propType !== "object") {
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
-          }
-          for (var key in shapeTypes) {
-            var checker = shapeTypes[key];
-            if (typeof checker !== "function") {
-              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
-            }
-            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
-            if (error) {
-              return error;
-            }
-          }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function createStrictShapeTypeChecker(shapeTypes) {
-        function validate(props, propName, componentName, location, propFullName) {
-          var propValue = props[propName];
-          var propType = getPropType(propValue);
-          if (propType !== "object") {
-            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
-          }
-          var allKeys = assign({}, props[propName], shapeTypes);
-          for (var key in allKeys) {
-            var checker = shapeTypes[key];
-            if (has(shapeTypes, key) && typeof checker !== "function") {
-              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
-            }
-            if (!checker) {
-              return new PropTypeError(
-                "Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, "  ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, "  ")
-              );
-            }
-            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
-            if (error) {
-              return error;
-            }
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ChatbotFooter.default, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          import_MessageBar.default,
+          {
+            onSendMessage: (m) => handleSend(String(m)),
+            hasAttachButton: false,
+            isSendButtonDisabled
           }
-          return null;
-        }
-        return createChainableTypeChecker(validate);
-      }
-      function isNode(propValue) {
-        switch (typeof propValue) {
-          case "number":
-          case "string":
-          case "undefined":
-            return true;
-          case "boolean":
-            return !propValue;
-          case "object":
-            if (Array.isArray(propValue)) {
-              return propValue.every(isNode);
-            }
-            if (propValue === null || isValidElement(propValue)) {
-              return true;
-            }
-            var iteratorFn = getIteratorFn(propValue);
-            if (iteratorFn) {
-              var iterator = iteratorFn.call(propValue);
-              var step;
-              if (iteratorFn !== propValue.entries) {
-                while (!(step = iterator.next()).done) {
-                  if (!isNode(step.value)) {
-                    return false;
-                  }
-                }
-              } else {
-                while (!(step = iterator.next()).done) {
-                  var entry = step.value;
-                  if (entry) {
-                    if (!isNode(entry[1])) {
-                      return false;
-                    }
-                  }
-                }
-              }
-            } else {
-              return false;
-            }
-            return true;
-          default:
-            return false;
-        }
-      }
-      function isSymbol(propType, propValue) {
-        if (propType === "symbol") {
-          return true;
-        }
-        if (!propValue) {
-          return false;
-        }
-        if (propValue["@@toStringTag"] === "Symbol") {
-          return true;
-        }
-        if (typeof Symbol === "function" && propValue instanceof Symbol) {
-          return true;
-        }
-        return false;
-      }
-      function getPropType(propValue) {
-        var propType = typeof propValue;
-        if (Array.isArray(propValue)) {
-          return "array";
-        }
-        if (propValue instanceof RegExp) {
-          return "object";
-        }
-        if (isSymbol(propType, propValue)) {
-          return "symbol";
-        }
-        return propType;
-      }
-      function getPreciseType(propValue) {
-        if (typeof propValue === "undefined" || propValue === null) {
-          return "" + propValue;
-        }
-        var propType = getPropType(propValue);
-        if (propType === "object") {
-          if (propValue instanceof Date) {
-            return "date";
-          } else if (propValue instanceof RegExp) {
-            return "regexp";
-          }
-        }
-        return propType;
-      }
-      function getPostfixForTypeWarning(value) {
-        var type = getPreciseType(value);
-        switch (type) {
-          case "array":
-          case "object":
-            return "an " + type;
-          case "boolean":
-          case "date":
-          case "regexp":
-            return "a " + type;
-          default:
-            return type;
-        }
-      }
-      function getClassName(propValue) {
-        if (!propValue.constructor || !propValue.constructor.name) {
-          return ANONYMOUS;
-        }
-        return propValue.constructor.name;
-      }
-      ReactPropTypes.checkPropTypes = checkPropTypes;
-      ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
-      ReactPropTypes.PropTypes = ReactPropTypes;
-      return ReactPropTypes;
-    };
-  }
-});
-
-// node_modules/prop-types/factoryWithThrowingShims.js
-var require_factoryWithThrowingShims = __commonJS({
-  "node_modules/prop-types/factoryWithThrowingShims.js"(exports2, module2) {
-    "use strict";
-    var ReactPropTypesSecret = require_ReactPropTypesSecret();
-    function emptyFunction() {
-    }
-    function emptyFunctionWithReset() {
-    }
-    emptyFunctionWithReset.resetWarningCache = emptyFunction;
-    module2.exports = function() {
-      function shim(props, propName, componentName, location, propFullName, secret) {
-        if (secret === ReactPropTypesSecret) {
-          return;
-        }
-        var err = new Error(
-          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
-        );
-        err.name = "Invariant Violation";
-        throw err;
-      }
-      ;
-      shim.isRequired = shim;
-      function getShim() {
-        return shim;
-      }
-      ;
-      var ReactPropTypes = {
-        array: shim,
-        bigint: shim,
-        bool: shim,
-        func: shim,
-        number: shim,
-        object: shim,
-        string: shim,
-        symbol: shim,
-        any: shim,
-        arrayOf: getShim,
-        element: shim,
-        elementType: shim,
-        instanceOf: getShim,
-        node: shim,
-        objectOf: getShim,
-        oneOf: getShim,
-        oneOfType: getShim,
-        shape: getShim,
-        exact: getShim,
-        checkPropTypes: emptyFunctionWithReset,
-        resetWarningCache: emptyFunction
-      };
-      ReactPropTypes.PropTypes = ReactPropTypes;
-      return ReactPropTypes;
-    };
-  }
-});
-
-// node_modules/prop-types/index.js
-var require_prop_types = __commonJS({
-  "node_modules/prop-types/index.js"(exports2, module2) {
-    "use strict";
-    if (process.env.NODE_ENV !== "production") {
-      ReactIs = require_react_is();
-      throwOnDirectAccess = true;
-      module2.exports = require_factoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
-    } else {
-      module2.exports = require_factoryWithThrowingShims()();
-    }
-    var ReactIs;
-    var throwOnDirectAccess;
-  }
-});
-
-// node_modules/split.js/dist/split.es.js
-var global, ssr, document2, addEventListener, removeEventListener, getBoundingClientRect, gutterStartDragging, aGutterSize, bGutterSize, HORIZONTAL, NOOP, calc, isString, elementOrSelector, getOption, getGutterSize, defaultGutterFn, defaultElementStyleFn, defaultGutterStyleFn, Split, split_es_default;
-var init_split_es = __esm({
-  "node_modules/split.js/dist/split.es.js"() {
-    "use strict";
-    global = typeof window !== "undefined" ? window : null;
-    ssr = global === null;
-    document2 = !ssr ? global.document : void 0;
-    addEventListener = "addEventListener";
-    removeEventListener = "removeEventListener";
-    getBoundingClientRect = "getBoundingClientRect";
-    gutterStartDragging = "_a";
-    aGutterSize = "_b";
-    bGutterSize = "_c";
-    HORIZONTAL = "horizontal";
-    NOOP = function() {
-      return false;
-    };
-    calc = ssr ? "calc" : ["", "-webkit-", "-moz-", "-o-"].filter(function(prefix) {
-      var el = document2.createElement("div");
-      el.style.cssText = "width:" + prefix + "calc(9px)";
-      return !!el.style.length;
-    }).shift() + "calc";
-    isString = function(v) {
-      return typeof v === "string" || v instanceof String;
-    };
-    elementOrSelector = function(el) {
-      if (isString(el)) {
-        var ele = document2.querySelector(el);
-        if (!ele) {
-          throw new Error("Selector " + el + " did not match a DOM element");
-        }
-        return ele;
-      }
-      return el;
-    };
-    getOption = function(options, propName, def) {
-      var value = options[propName];
-      if (value !== void 0) {
-        return value;
-      }
-      return def;
-    };
-    getGutterSize = function(gutterSize, isFirst, isLast, gutterAlign) {
-      if (isFirst) {
-        if (gutterAlign === "end") {
-          return 0;
-        }
-        if (gutterAlign === "center") {
-          return gutterSize / 2;
-        }
-      } else if (isLast) {
-        if (gutterAlign === "start") {
-          return 0;
-        }
-        if (gutterAlign === "center") {
-          return gutterSize / 2;
-        }
-      }
-      return gutterSize;
-    };
-    defaultGutterFn = function(i, gutterDirection) {
-      var gut = document2.createElement("div");
-      gut.className = "gutter gutter-" + gutterDirection;
-      return gut;
-    };
-    defaultElementStyleFn = function(dim, size, gutSize) {
-      var style = {};
-      if (!isString(size)) {
-        style[dim] = calc + "(" + size + "% - " + gutSize + "px)";
-      } else {
-        style[dim] = size;
-      }
-      return style;
-    };
-    defaultGutterStyleFn = function(dim, gutSize) {
-      var obj;
-      return obj = {}, obj[dim] = gutSize + "px", obj;
-    };
-    Split = function(idsOption, options) {
-      if (options === void 0) options = {};
-      if (ssr) {
-        return {};
-      }
-      var ids = idsOption;
-      var dimension;
-      var clientAxis;
-      var position;
-      var positionEnd;
-      var clientSize;
-      var elements;
-      if (Array.from) {
-        ids = Array.from(ids);
-      }
-      var firstElement = elementOrSelector(ids[0]);
-      var parent = firstElement.parentNode;
-      var parentStyle = getComputedStyle ? getComputedStyle(parent) : null;
-      var parentFlexDirection = parentStyle ? parentStyle.flexDirection : null;
-      var sizes = getOption(options, "sizes") || ids.map(function() {
-        return 100 / ids.length;
-      });
-      var minSize = getOption(options, "minSize", 100);
-      var minSizes = Array.isArray(minSize) ? minSize : ids.map(function() {
-        return minSize;
-      });
-      var maxSize = getOption(options, "maxSize", Infinity);
-      var maxSizes = Array.isArray(maxSize) ? maxSize : ids.map(function() {
-        return maxSize;
-      });
-      var expandToMin = getOption(options, "expandToMin", false);
-      var gutterSize = getOption(options, "gutterSize", 10);
-      var gutterAlign = getOption(options, "gutterAlign", "center");
-      var snapOffset = getOption(options, "snapOffset", 30);
-      var snapOffsets = Array.isArray(snapOffset) ? snapOffset : ids.map(function() {
-        return snapOffset;
-      });
-      var dragInterval = getOption(options, "dragInterval", 1);
-      var direction = getOption(options, "direction", HORIZONTAL);
-      var cursor = getOption(
-        options,
-        "cursor",
-        direction === HORIZONTAL ? "col-resize" : "row-resize"
-      );
-      var gutter = getOption(options, "gutter", defaultGutterFn);
-      var elementStyle = getOption(
-        options,
-        "elementStyle",
-        defaultElementStyleFn
-      );
-      var gutterStyle = getOption(options, "gutterStyle", defaultGutterStyleFn);
-      if (direction === HORIZONTAL) {
-        dimension = "width";
-        clientAxis = "clientX";
-        position = "left";
-        positionEnd = "right";
-        clientSize = "clientWidth";
-      } else if (direction === "vertical") {
-        dimension = "height";
-        clientAxis = "clientY";
-        position = "top";
-        positionEnd = "bottom";
-        clientSize = "clientHeight";
-      }
-      function setElementSize(el, size, gutSize, i) {
-        var style = elementStyle(dimension, size, gutSize, i);
-        Object.keys(style).forEach(function(prop) {
-          el.style[prop] = style[prop];
-        });
-      }
-      function setGutterSize(gutterElement, gutSize, i) {
-        var style = gutterStyle(dimension, gutSize, i);
-        Object.keys(style).forEach(function(prop) {
-          gutterElement.style[prop] = style[prop];
-        });
-      }
-      function getSizes() {
-        return elements.map(function(element) {
-          return element.size;
-        });
-      }
-      function getMousePosition(e) {
-        if ("touches" in e) {
-          return e.touches[0][clientAxis];
-        }
-        return e[clientAxis];
-      }
-      function adjust(offset) {
-        var a = elements[this.a];
-        var b = elements[this.b];
-        var percentage = a.size + b.size;
-        a.size = offset / this.size * percentage;
-        b.size = percentage - offset / this.size * percentage;
-        setElementSize(a.element, a.size, this[aGutterSize], a.i);
-        setElementSize(b.element, b.size, this[bGutterSize], b.i);
-      }
-      function drag(e) {
-        var offset;
-        var a = elements[this.a];
-        var b = elements[this.b];
-        if (!this.dragging) {
-          return;
-        }
-        offset = getMousePosition(e) - this.start + (this[aGutterSize] - this.dragOffset);
-        if (dragInterval > 1) {
-          offset = Math.round(offset / dragInterval) * dragInterval;
-        }
-        if (offset <= a.minSize + a.snapOffset + this[aGutterSize]) {
-          offset = a.minSize + this[aGutterSize];
-        } else if (offset >= this.size - (b.minSize + b.snapOffset + this[bGutterSize])) {
-          offset = this.size - (b.minSize + this[bGutterSize]);
-        }
-        if (offset >= a.maxSize - a.snapOffset + this[aGutterSize]) {
-          offset = a.maxSize + this[aGutterSize];
-        } else if (offset <= this.size - (b.maxSize - b.snapOffset + this[bGutterSize])) {
-          offset = this.size - (b.maxSize + this[bGutterSize]);
-        }
-        adjust.call(this, offset);
-        getOption(options, "onDrag", NOOP)(getSizes());
-      }
-      function calculateSizes() {
-        var a = elements[this.a].element;
-        var b = elements[this.b].element;
-        var aBounds = a[getBoundingClientRect]();
-        var bBounds = b[getBoundingClientRect]();
-        this.size = aBounds[dimension] + bBounds[dimension] + this[aGutterSize] + this[bGutterSize];
-        this.start = aBounds[position];
-        this.end = aBounds[positionEnd];
-      }
-      function innerSize(element) {
-        if (!getComputedStyle) {
-          return null;
-        }
-        var computedStyle = getComputedStyle(element);
-        if (!computedStyle) {
-          return null;
-        }
-        var size = element[clientSize];
-        if (size === 0) {
-          return null;
-        }
-        if (direction === HORIZONTAL) {
-          size -= parseFloat(computedStyle.paddingLeft) + parseFloat(computedStyle.paddingRight);
-        } else {
-          size -= parseFloat(computedStyle.paddingTop) + parseFloat(computedStyle.paddingBottom);
-        }
-        return size;
-      }
-      function trimToMin(sizesToTrim) {
-        var parentSize = innerSize(parent);
-        if (parentSize === null) {
-          return sizesToTrim;
-        }
-        if (minSizes.reduce(function(a, b) {
-          return a + b;
-        }, 0) > parentSize) {
-          return sizesToTrim;
-        }
-        var excessPixels = 0;
-        var toSpare = [];
-        var pixelSizes = sizesToTrim.map(function(size, i) {
-          var pixelSize = parentSize * size / 100;
-          var elementGutterSize = getGutterSize(
-            gutterSize,
-            i === 0,
-            i === sizesToTrim.length - 1,
-            gutterAlign
-          );
-          var elementMinSize = minSizes[i] + elementGutterSize;
-          if (pixelSize < elementMinSize) {
-            excessPixels += elementMinSize - pixelSize;
-            toSpare.push(0);
-            return elementMinSize;
-          }
-          toSpare.push(pixelSize - elementMinSize);
-          return pixelSize;
-        });
-        if (excessPixels === 0) {
-          return sizesToTrim;
-        }
-        return pixelSizes.map(function(pixelSize, i) {
-          var newPixelSize = pixelSize;
-          if (excessPixels > 0 && toSpare[i] - excessPixels > 0) {
-            var takenPixels = Math.min(
-              excessPixels,
-              toSpare[i] - excessPixels
-            );
-            excessPixels -= takenPixels;
-            newPixelSize = pixelSize - takenPixels;
-          }
-          return newPixelSize / parentSize * 100;
-        });
-      }
-      function stopDragging() {
-        var self = this;
-        var a = elements[self.a].element;
-        var b = elements[self.b].element;
-        if (self.dragging) {
-          getOption(options, "onDragEnd", NOOP)(getSizes());
-        }
-        self.dragging = false;
-        global[removeEventListener]("mouseup", self.stop);
-        global[removeEventListener]("touchend", self.stop);
-        global[removeEventListener]("touchcancel", self.stop);
-        global[removeEventListener]("mousemove", self.move);
-        global[removeEventListener]("touchmove", self.move);
-        self.stop = null;
-        self.move = null;
-        a[removeEventListener]("selectstart", NOOP);
-        a[removeEventListener]("dragstart", NOOP);
-        b[removeEventListener]("selectstart", NOOP);
-        b[removeEventListener]("dragstart", NOOP);
-        a.style.userSelect = "";
-        a.style.webkitUserSelect = "";
-        a.style.MozUserSelect = "";
-        a.style.pointerEvents = "";
-        b.style.userSelect = "";
-        b.style.webkitUserSelect = "";
-        b.style.MozUserSelect = "";
-        b.style.pointerEvents = "";
-        self.gutter.style.cursor = "";
-        self.parent.style.cursor = "";
-        document2.body.style.cursor = "";
-      }
-      function startDragging(e) {
-        if ("button" in e && e.button !== 0) {
-          return;
-        }
-        var self = this;
-        var a = elements[self.a].element;
-        var b = elements[self.b].element;
-        if (!self.dragging) {
-          getOption(options, "onDragStart", NOOP)(getSizes());
-        }
-        e.preventDefault();
-        self.dragging = true;
-        self.move = drag.bind(self);
-        self.stop = stopDragging.bind(self);
-        global[addEventListener]("mouseup", self.stop);
-        global[addEventListener]("touchend", self.stop);
-        global[addEventListener]("touchcancel", self.stop);
-        global[addEventListener]("mousemove", self.move);
-        global[addEventListener]("touchmove", self.move);
-        a[addEventListener]("selectstart", NOOP);
-        a[addEventListener]("dragstart", NOOP);
-        b[addEventListener]("selectstart", NOOP);
-        b[addEventListener]("dragstart", NOOP);
-        a.style.userSelect = "none";
-        a.style.webkitUserSelect = "none";
-        a.style.MozUserSelect = "none";
-        a.style.pointerEvents = "none";
-        b.style.userSelect = "none";
-        b.style.webkitUserSelect = "none";
-        b.style.MozUserSelect = "none";
-        b.style.pointerEvents = "none";
-        self.gutter.style.cursor = cursor;
-        self.parent.style.cursor = cursor;
-        document2.body.style.cursor = cursor;
-        calculateSizes.call(self);
-        self.dragOffset = getMousePosition(e) - self.end;
-      }
-      sizes = trimToMin(sizes);
-      var pairs = [];
-      elements = ids.map(function(id, i) {
-        var element = {
-          element: elementOrSelector(id),
-          size: sizes[i],
-          minSize: minSizes[i],
-          maxSize: maxSizes[i],
-          snapOffset: snapOffsets[i],
-          i
-        };
-        var pair;
-        if (i > 0) {
-          pair = {
-            a: i - 1,
-            b: i,
-            dragging: false,
-            direction,
-            parent
-          };
-          pair[aGutterSize] = getGutterSize(
-            gutterSize,
-            i - 1 === 0,
-            false,
-            gutterAlign
-          );
-          pair[bGutterSize] = getGutterSize(
-            gutterSize,
-            false,
-            i === ids.length - 1,
-            gutterAlign
-          );
-          if (parentFlexDirection === "row-reverse" || parentFlexDirection === "column-reverse") {
-            var temp = pair.a;
-            pair.a = pair.b;
-            pair.b = temp;
-          }
-        }
-        if (i > 0) {
-          var gutterElement = gutter(i, direction, element.element);
-          setGutterSize(gutterElement, gutterSize, i);
-          pair[gutterStartDragging] = startDragging.bind(pair);
-          gutterElement[addEventListener](
-            "mousedown",
-            pair[gutterStartDragging]
-          );
-          gutterElement[addEventListener](
-            "touchstart",
-            pair[gutterStartDragging]
-          );
-          parent.insertBefore(gutterElement, element.element);
-          pair.gutter = gutterElement;
-        }
-        setElementSize(
-          element.element,
-          element.size,
-          getGutterSize(
-            gutterSize,
-            i === 0,
-            i === ids.length - 1,
-            gutterAlign
-          ),
-          i
-        );
-        if (i > 0) {
-          pairs.push(pair);
-        }
-        return element;
-      });
-      function adjustToMin(element) {
-        var isLast = element.i === pairs.length;
-        var pair = isLast ? pairs[element.i - 1] : pairs[element.i];
-        calculateSizes.call(pair);
-        var size = isLast ? pair.size - element.minSize - pair[bGutterSize] : element.minSize + pair[aGutterSize];
-        adjust.call(pair, size);
-      }
-      elements.forEach(function(element) {
-        var computedSize = element.element[getBoundingClientRect]()[dimension];
-        if (computedSize < element.minSize) {
-          if (expandToMin) {
-            adjustToMin(element);
-          } else {
-            element.minSize = computedSize;
-          }
-        }
-      });
-      function setSizes(newSizes) {
-        var trimmed = trimToMin(newSizes);
-        trimmed.forEach(function(newSize, i) {
-          if (i > 0) {
-            var pair = pairs[i - 1];
-            var a = elements[pair.a];
-            var b = elements[pair.b];
-            a.size = trimmed[i - 1];
-            b.size = newSize;
-            setElementSize(a.element, a.size, pair[aGutterSize], a.i);
-            setElementSize(b.element, b.size, pair[bGutterSize], b.i);
-          }
-        });
-      }
-      function destroy(preserveStyles, preserveGutter) {
-        pairs.forEach(function(pair) {
-          if (preserveGutter !== true) {
-            pair.parent.removeChild(pair.gutter);
-          } else {
-            pair.gutter[removeEventListener](
-              "mousedown",
-              pair[gutterStartDragging]
-            );
-            pair.gutter[removeEventListener](
-              "touchstart",
-              pair[gutterStartDragging]
-            );
-          }
-          if (preserveStyles !== true) {
-            var style = elementStyle(
-              dimension,
-              pair.a.size,
-              pair[aGutterSize]
-            );
-            Object.keys(style).forEach(function(prop) {
-              elements[pair.a].element.style[prop] = "";
-              elements[pair.b].element.style[prop] = "";
-            });
-          }
-        });
-      }
-      return {
-        setSizes,
-        getSizes,
-        collapse: function collapse(i) {
-          adjustToMin(elements[i]);
-        },
-        destroy,
-        parent,
-        pairs
-      };
-    };
-    split_es_default = Split;
-  }
-});
-
-// node_modules/react-split/dist/react-split.es.js
-function objectWithoutProperties(obj, exclude) {
-  var target = {};
-  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) target[k] = obj[k];
-  return target;
-}
-var import_react5, import_prop_types, SplitWrapper, react_split_es_default;
-var init_react_split_es = __esm({
-  "node_modules/react-split/dist/react-split.es.js"() {
-    "use strict";
-    import_react5 = __toESM(require("react"));
-    import_prop_types = __toESM(require_prop_types());
-    init_split_es();
-    SplitWrapper = /* @__PURE__ */ (function(superclass) {
-      function SplitWrapper2() {
-        superclass.apply(this, arguments);
-      }
-      if (superclass) SplitWrapper2.__proto__ = superclass;
-      SplitWrapper2.prototype = Object.create(superclass && superclass.prototype);
-      SplitWrapper2.prototype.constructor = SplitWrapper2;
-      SplitWrapper2.prototype.componentDidMount = function componentDidMount() {
-        var ref = this.props;
-        ref.children;
-        var gutter = ref.gutter;
-        var rest = objectWithoutProperties(ref, ["children", "gutter"]);
-        var options = rest;
-        options.gutter = function(index, direction) {
-          var gutterElement;
-          if (gutter) {
-            gutterElement = gutter(index, direction);
-          } else {
-            gutterElement = document.createElement("div");
-            gutterElement.className = "gutter gutter-" + direction;
-          }
-          gutterElement.__isSplitGutter = true;
-          return gutterElement;
-        };
-        this.split = split_es_default(this.parent.children, options);
-      };
-      SplitWrapper2.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
-        var this$1 = this;
-        var ref = this.props;
-        ref.children;
-        var minSize = ref.minSize;
-        var sizes = ref.sizes;
-        var collapsed = ref.collapsed;
-        var rest = objectWithoutProperties(ref, ["children", "minSize", "sizes", "collapsed"]);
-        var options = rest;
-        var prevMinSize = prevProps.minSize;
-        var prevSizes = prevProps.sizes;
-        var prevCollapsed = prevProps.collapsed;
-        var otherProps = [
-          "maxSize",
-          "expandToMin",
-          "gutterSize",
-          "gutterAlign",
-          "snapOffset",
-          "dragInterval",
-          "direction",
-          "cursor"
-        ];
-        var needsRecreate = otherProps.map(function(prop) {
-          return this$1.props[prop] !== prevProps[prop];
-        }).reduce(function(accum, same) {
-          return accum || same;
-        }, false);
-        if (Array.isArray(minSize) && Array.isArray(prevMinSize)) {
-          var minSizeChanged = false;
-          minSize.forEach(function(minSizeI, i) {
-            minSizeChanged = minSizeChanged || minSizeI !== prevMinSize[i];
-          });
-          needsRecreate = needsRecreate || minSizeChanged;
-        } else if (Array.isArray(minSize) || Array.isArray(prevMinSize)) {
-          needsRecreate = true;
-        } else {
-          needsRecreate = needsRecreate || minSize !== prevMinSize;
-        }
-        if (needsRecreate) {
-          options.minSize = minSize;
-          options.sizes = sizes || this.split.getSizes();
-          this.split.destroy(true, true);
-          options.gutter = function(index, direction, pairB) {
-            return pairB.previousSibling;
-          };
-          this.split = split_es_default(
-            Array.from(this.parent.children).filter(
-              // eslint-disable-next-line no-underscore-dangle
-              function(element) {
-                return !element.__isSplitGutter;
-              }
-            ),
-            options
-          );
-        } else if (sizes) {
-          var sizeChanged = false;
-          sizes.forEach(function(sizeI, i) {
-            sizeChanged = sizeChanged || sizeI !== prevSizes[i];
-          });
-          if (sizeChanged) {
-            this.split.setSizes(this.props.sizes);
-          }
-        }
-        if (Number.isInteger(collapsed) && (collapsed !== prevCollapsed || needsRecreate)) {
-          this.split.collapse(collapsed);
-        }
-      };
-      SplitWrapper2.prototype.componentWillUnmount = function componentWillUnmount() {
-        this.split.destroy();
-        delete this.split;
-      };
-      SplitWrapper2.prototype.render = function render() {
-        var this$1 = this;
-        var ref = this.props;
-        ref.sizes;
-        ref.minSize;
-        ref.maxSize;
-        ref.expandToMin;
-        ref.gutterSize;
-        ref.gutterAlign;
-        ref.snapOffset;
-        ref.dragInterval;
-        ref.direction;
-        ref.cursor;
-        ref.gutter;
-        ref.elementStyle;
-        ref.gutterStyle;
-        ref.onDrag;
-        ref.onDragStart;
-        ref.onDragEnd;
-        ref.collapsed;
-        var children = ref.children;
-        var rest$1 = objectWithoutProperties(ref, ["sizes", "minSize", "maxSize", "expandToMin", "gutterSize", "gutterAlign", "snapOffset", "dragInterval", "direction", "cursor", "gutter", "elementStyle", "gutterStyle", "onDrag", "onDragStart", "onDragEnd", "collapsed", "children"]);
-        var rest = rest$1;
-        return import_react5.default.createElement(
-          "div",
-          Object.assign(
-            {},
-            { ref: function(parent) {
-              this$1.parent = parent;
-            } },
-            rest
-          ),
-          children
-        );
-      };
-      return SplitWrapper2;
-    })(import_react5.default.Component);
-    SplitWrapper.propTypes = {
-      sizes: import_prop_types.default.arrayOf(import_prop_types.default.number),
-      minSize: import_prop_types.default.oneOfType([
-        import_prop_types.default.number,
-        import_prop_types.default.arrayOf(import_prop_types.default.number)
-      ]),
-      maxSize: import_prop_types.default.oneOfType([
-        import_prop_types.default.number,
-        import_prop_types.default.arrayOf(import_prop_types.default.number)
-      ]),
-      expandToMin: import_prop_types.default.bool,
-      gutterSize: import_prop_types.default.number,
-      gutterAlign: import_prop_types.default.string,
-      snapOffset: import_prop_types.default.oneOfType([
-        import_prop_types.default.number,
-        import_prop_types.default.arrayOf(import_prop_types.default.number)
-      ]),
-      dragInterval: import_prop_types.default.number,
-      direction: import_prop_types.default.string,
-      cursor: import_prop_types.default.string,
-      gutter: import_prop_types.default.func,
-      elementStyle: import_prop_types.default.func,
-      gutterStyle: import_prop_types.default.func,
-      onDrag: import_prop_types.default.func,
-      onDragStart: import_prop_types.default.func,
-      onDragEnd: import_prop_types.default.func,
-      collapsed: import_prop_types.default.number,
-      children: import_prop_types.default.arrayOf(import_prop_types.default.element)
-    };
-    SplitWrapper.defaultProps = {
-      sizes: void 0,
-      minSize: void 0,
-      maxSize: void 0,
-      expandToMin: void 0,
-      gutterSize: void 0,
-      gutterAlign: void 0,
-      snapOffset: void 0,
-      dragInterval: void 0,
-      direction: void 0,
-      cursor: void 0,
-      gutter: void 0,
-      elementStyle: void 0,
-      gutterStyle: void 0,
-      onDrag: void 0,
-      onDragStart: void 0,
-      onDragEnd: void 0,
-      collapsed: void 0,
-      children: void 0
-    };
-    react_split_es_default = SplitWrapper;
-  }
-});
-
-// src/ai-plugin/jmx-ai/model.ts
-var ChatbotDialog;
-var init_model = __esm({
-  "src/ai-plugin/jmx-ai/model.ts"() {
-    "use strict";
-    ChatbotDialog = class {
-      constructor(messages, summary) {
-        this.messages = messages;
-        this.summary = summary;
-        this.id = messages[0]?.id ?? "";
-      }
-      messages;
-      summary;
-      id;
-      setMessages(messages) {
-        if (messages[0]?.id !== this.id) {
-          throw new Error("Not the same dialog");
-        }
-        this.messages = [...messages];
-      }
-      createConversation() {
-        const text = this.summary ?? (this.messages[0]?.content ?? "").substring(0, 20);
-        return { id: this.id, text };
-      }
-    };
-  }
-});
-
-// src/ai-plugin/jmx-ai/context.ts
-function useMBeanTree() {
-  const [tree, setTree] = (0, import_react7.useState)(import_react6.MBeanTree.createEmpty(pluginName));
-  const [loaded, setLoaded] = (0, import_react7.useState)(false);
-  const { selectedNode, setSelectedNode } = (0, import_react7.useContext)(import_react6.PluginNodeSelectionContext);
-  const navigate = (0, import_react_router_dom.useNavigate)();
-  const [searchParams, setSearchParams] = (0, import_react_router_dom.useSearchParams)();
-  const refSelectedNode = (0, import_react7.useRef)();
-  refSelectedNode.current = selectedNode;
-  const populateTree = async () => {
-    const wkspTree = await import_react6.workspace.getTree();
-    setTree(wkspTree);
-    const nodeId = searchParams.get(PARAM_KEY_NODE_ID);
-    if (nodeId && nodeId !== refSelectedNode.current?.id) {
-      log.debug("Restore selected node with nid:", nodeId);
-      const urlNode = wkspTree.find((node) => node.id === nodeId);
-      if (urlNode) {
-        setSelectedNode(urlNode);
-        refSelectedNode.current = urlNode;
-      } else {
-        log.debug("Clear invalid nid:", nodeId);
-        searchParams.delete(PARAM_KEY_NODE_ID);
-        setSearchParams(searchParams);
-      }
-    }
-    if (!refSelectedNode.current) return;
-    const path = [...refSelectedNode.current.path()];
-    wkspTree.forEach(path, (node) => {
-      node.defaultExpanded = true;
-    });
-    const newSelected = wkspTree.navigate(...path);
-    if (newSelected) {
-      setSelectedNode(newSelected);
-      navigate(pluginPathWithNodeId(newSelected, searchParams));
-    } else {
-      navigate(pluginPath);
-    }
-  };
-  (0, import_react7.useEffect)(() => {
-    const loadTree = async () => {
-      await populateTree();
-      setLoaded(true);
-    };
-    const listener = () => {
-      setLoaded(false);
-      loadTree();
-    };
-    import_react6.eventService.onRefresh(listener);
-    loadTree();
-    return () => import_react6.eventService.removeListener(import_react6.EVENT_REFRESH, listener);
-  }, []);
-  return { tree, loaded, selectedNode, setSelectedNode };
-}
-function pluginPathWithNodeId(node, searchParams = new URLSearchParams(window.location.search)) {
-  searchParams.set(PARAM_KEY_NODE_ID, node.id);
-  const query = `?${searchParams.toString()}`;
-  return { pathname: pluginPath, search: query };
-}
-function useChatbot() {
-  const [messages, setMessages2] = (0, import_react7.useState)([]);
-  const [dialogs, setDialogs] = (0, import_react7.useState)([]);
-  const [conversations, setConversations] = (0, import_react7.useState)([]);
-  const [announcement, setAnnouncement] = (0, import_react7.useState)("");
-  const [isChatbotOpen, setIsChatbotOpen] = (0, import_react7.useState)(false);
-  const [isSendButtonDisabled, setIsSendButtonDisabled] = (0, import_react7.useState)(false);
-  const updateConversations = (messages2, summary) => {
-    const dialogId = messages2[0]?.id;
-    if (!dialogId) {
-      return;
-    }
-    setMessages2(messages2);
-    let dialog = dialogs.find((d) => d.id === dialogId);
-    if (dialog) {
-      dialog.setMessages(messages2);
-    } else {
-      dialog = new ChatbotDialog(messages2, summary);
-      dialogs.push(dialog);
-    }
-    setDialogs([...dialogs]);
-    log.debug("Updated dialogs:", dialogs);
-    if (!conversations.some((c) => c.id === dialogId)) {
-      const conversation = dialog.createConversation();
-      conversations.push(conversation);
-      setConversations([...conversations]);
-      log.debug("Updated conversations:", conversations);
-    }
-  };
-  return {
-    messages,
-    setMessages: setMessages2,
-    dialogs,
-    setDialogs,
-    conversations,
-    setConversations,
-    announcement,
-    setAnnouncement,
-    isChatbotOpen,
-    setIsChatbotOpen,
-    isSendButtonDisabled,
-    setIsSendButtonDisabled,
-    updateConversations
-  };
-}
-var import_react6, import_react7, import_react_router_dom, MBeanTreeContext, ChatbotContext;
-var init_context = __esm({
-  "src/ai-plugin/jmx-ai/context.ts"() {
-    "use strict";
-    import_react6 = require("@hawtio/react");
-    import_react7 = require("react");
-    import_react_router_dom = require("react-router-dom");
-    init_globals();
-    init_model();
-    MBeanTreeContext = (0, import_react7.createContext)({
-      tree: import_react6.MBeanTree.createEmpty(pluginName),
-      loaded: false,
-      selectedNode: null,
-      setSelectedNode: () => {
-      }
-    });
-    ChatbotContext = (0, import_react7.createContext)({
-      messages: [],
-      setMessages: () => {
-      },
-      dialogs: [],
-      setDialogs: () => {
-      },
-      conversations: [],
-      setConversations: () => {
-      },
-      announcement: "",
-      setAnnouncement: () => {
-      },
-      isChatbotOpen: false,
-      setIsChatbotOpen: () => {
-      },
-      isSendButtonDisabled: false,
-      setIsSendButtonDisabled: () => {
-      },
-      updateConversations: () => {
-      }
-    });
-  }
-});
-
-// src/ai-plugin/jmx-ai/Jmx.css
-var init_Jmx = __esm({
-  "src/ai-plugin/jmx-ai/Jmx.css"() {
-  }
-});
-
-// src/ai-plugin/jmx-ai/DiagnosisChatbot.tsx
-var import_ui, import_Chatbot, import_ChatbotContent, import_ChatbotConversationHistoryNav, import_ChatbotFooter, import_ChatbotHeader, import_Message, import_MessageBar, import_MessageBox, import_react_core2, import_wrench_icon, import_react8, import_jsx_runtime2, DiagnosisChatbot, DiagnosisChatbotHeader, DiagnosisChatbotContent, DiagnosisChatbotFooter, ThinkInfo, ToolCallsInfo, ToolCallsApprove;
-var init_DiagnosisChatbot = __esm({
-  "src/ai-plugin/jmx-ai/DiagnosisChatbot.tsx"() {
-    "use strict";
-    import_ui = require("@hawtio/react/ui");
-    import_Chatbot = __toESM(require("@patternfly/chatbot/dist/dynamic/Chatbot"));
-    import_ChatbotContent = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotContent"));
-    import_ChatbotConversationHistoryNav = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotConversationHistoryNav"));
-    import_ChatbotFooter = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotFooter"));
-    import_ChatbotHeader = __toESM(require("@patternfly/chatbot/dist/dynamic/ChatbotHeader"));
-    import_Message = __toESM(require("@patternfly/chatbot/dist/dynamic/Message"));
-    import_MessageBar = __toESM(require("@patternfly/chatbot/dist/dynamic/MessageBar"));
-    import_MessageBox = __toESM(require("@patternfly/chatbot/dist/dynamic/MessageBox"));
-    import_react_core2 = require("@patternfly/react-core");
-    import_wrench_icon = __toESM(require("@patternfly/react-icons/dist/esm/icons/wrench-icon"));
-    import_react8 = __toESM(require("react"));
-    init_ai_service();
-    init_context();
-    init_globals();
-    import_jsx_runtime2 = require("react/jsx-runtime");
-    DiagnosisChatbot = () => {
-      const { setMessages: setMessages2, dialogs, conversations } = (0, import_react8.useContext)(ChatbotContext);
-      const [isDrawerOpen, setIsDrawerOpen] = (0, import_react8.useState)(false);
-      const [filteredConversations, setFilteredConversations] = (0, import_react8.useState)(conversations);
-      const onSelectItemInHistory = (selected) => {
-        log.debug("Selected conversation with ID:", selected);
-        const dialog = dialogs.find((c) => c.id === selected);
-        if (dialog) {
-          setMessages2(dialog.messages);
-          setIsDrawerOpen(!isDrawerOpen);
-        }
-      };
-      const handleSearchTextChange = (value) => {
-        if (value.trim() === "") {
-          setFilteredConversations(conversations);
-          return;
-        }
-        const filtered = conversations.filter((c) => c.text.toLowerCase().includes(value.toLowerCase()));
-        log.debug("Filtered conversations:", filtered);
-        setFilteredConversations(filtered);
-      };
-      const displayMode = import_Chatbot.ChatbotDisplayMode.drawer;
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Chatbot.default, { isCompact: true, displayMode, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-        import_ChatbotConversationHistoryNav.default,
-        {
-          isCompact: true,
-          drawerPanelContentProps: { isResizable: true, minSize: "200px" },
-          displayMode,
-          onDrawerToggle: () => {
-            setIsDrawerOpen(!isDrawerOpen);
-            setFilteredConversations(conversations);
-          },
-          isDrawerOpen,
-          setIsDrawerOpen,
-          onSelectActiveItem: (_e, selectedItem) => onSelectItemInHistory(String(selectedItem)),
-          conversations: [...filteredConversations].reverse(),
-          onNewChat: () => {
-            setIsDrawerOpen(!isDrawerOpen);
-            setFilteredConversations(conversations);
-            setMessages2([]);
-          },
-          handleTextInputChange: handleSearchTextChange,
-          drawerContent: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(DiagnosisChatbotHeader, { isDrawerOpen, setIsDrawerOpen }),
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(DiagnosisChatbotContent, {}),
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(DiagnosisChatbotFooter, {})
-          ] })
-        }
-      ) });
-    };
-    DiagnosisChatbotHeader = ({ isDrawerOpen, setIsDrawerOpen }) => {
-      const { setIsChatbotOpen } = (0, import_react8.useContext)(ChatbotContext);
-      const modelName = aiService.getModel()?.name;
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ChatbotHeader.default, { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ChatbotHeader.ChatbotHeaderMain, { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ChatbotHeader.ChatbotHeaderMenu, { "aria-expanded": isDrawerOpen, onMenuToggle: () => setIsDrawerOpen(!isDrawerOpen) }),
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ChatbotHeader.ChatbotHeaderTitle, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_core2.Content, { component: "h2", children: "AI - Diagnosis" }) })
-        ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ChatbotHeader.ChatbotHeaderActions, { children: [
-          modelName && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_core2.Label, { variant: "outline", children: modelName }),
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ChatbotHeader.ChatbotHeaderCloseButton, { onClick: () => setIsChatbotOpen(false) })
-        ] })
-      ] });
-    };
-    DiagnosisChatbotContent = () => {
-      const { messages, announcement } = (0, import_react8.useContext)(ChatbotContext);
-      const scrollToBottomRef = (0, import_react8.useRef)(null);
-      (0, import_react8.useEffect)(() => {
-        if (messages.length > 2) {
-          scrollToBottomRef.current?.scrollIntoView({ behavior: "smooth" });
-        }
-      }, [messages]);
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ChatbotContent.default, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_MessageBox.default, { announcement, children: messages.map((message, index) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.default.Fragment, { children: [
-        index === messages.length - 1 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { ref: scrollToBottomRef }),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Message.default, { ...message }, message.id)
-      ] }, message.id)) }) });
-    };
-    DiagnosisChatbotFooter = () => {
-      const { username } = (0, import_react8.useContext)(import_ui.PageContext);
-      const { messages, setAnnouncement, isSendButtonDisabled, setIsSendButtonDisabled, updateConversations } = (0, import_react8.useContext)(ChatbotContext);
-      const messagesRef = (0, import_react8.useRef)(messages);
-      (0, import_react8.useEffect)(() => {
-        messagesRef.current = messages;
-      }, [messages]);
-      const handleSend = async (message) => {
-        if (!message.trim()) {
-          return;
-        }
-        log.debug("Send", messagesRef.current);
-        setIsSendButtonDisabled(true);
-        const newMessages = [];
-        newMessages.push(...messagesRef.current);
-        newMessages.push(aiService.createUserMessage(username, message));
-        newMessages.push(aiService.createLoadingBotMessage());
-        updateConversations(newMessages);
-        setAnnouncement(`Message from User: ${message}. Message from Bot is loading.`);
-        log.debug("handleSend - new messages:", newMessages);
-        const dialogId = newMessages[0].id;
-        const answer = await (newMessages.length === 2 ? aiService.newChat(dialogId, message) : aiService.chat(dialogId, message));
-        const loadedMessages = [];
-        loadedMessages.push(...newMessages);
-        log.debug("handleSend - loaded messages:", loadedMessages);
-        loadedMessages.pop();
-        const botMessage = aiService.toBotMessage(answer, ThinkInfo, ToolCallsInfo, ToolCallsApprove);
-        loadedMessages.push(botMessage);
-        updateConversations(loadedMessages);
-        setAnnouncement(`Message from Bot: ${answer}`);
-        setIsSendButtonDisabled(false);
-      };
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ChatbotFooter.default, { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-          import_MessageBar.default,
-          {
-            onSendMessage: (m) => handleSend(String(m)),
-            hasAttachButton: false,
-            isSendButtonDisabled
-          }
-        ),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ChatbotFooter.ChatbotFootnote, { label: "AI may be inaccurate. Please verify important information." })
-      ] });
-    };
-    ThinkInfo = (think) => {
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_core2.Alert, { variant: "info", title: "Think", isExpandable: true, children: think });
-    };
-    ToolCallsInfo = (call, index) => {
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_core2.Alert, { variant: "info", customIcon: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_wrench_icon.default, {}), title: call.name, isExpandable: true, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("p", { children: [
-        "Args: ",
-        JSON.stringify(call.args),
-        " "
-      ] }) }, index);
-    };
-    ToolCallsApprove = (toolCalls) => {
-      const { username } = (0, import_react8.useContext)(import_ui.PageContext);
-      const { messages, setAnnouncement, setIsSendButtonDisabled, updateConversations } = (0, import_react8.useContext)(ChatbotContext);
-      const messagesRef = (0, import_react8.useRef)(messages);
-      const approve = async (toolCalls2) => {
-        log.debug("Approved", messagesRef.current);
-        setIsSendButtonDisabled(true);
-        const newMessages = [];
-        newMessages.push(...messagesRef.current);
-        newMessages.push(aiService.createUserMessage(username, "Approved"));
-        newMessages.push(aiService.createLoadingBotMessage());
-        updateConversations(newMessages);
-        setAnnouncement(`User approved tool usage. Message from Bot is loading.`);
-        log.debug("approve - newMessages:", newMessages);
-        const answer = await aiService.invokeTools(toolCalls2);
-        log.debug("Answer:", answer);
-        const loadedMessages = [];
-        loadedMessages.push(...newMessages);
-        log.debug("approve - loadedMessages:", loadedMessages);
-        loadedMessages.pop();
-        const botMessage = aiService.toBotMessage(answer, ThinkInfo, ToolCallsInfo, ToolCallsApprove);
-        loadedMessages.push(botMessage);
-        updateConversations(loadedMessages);
-        setAnnouncement(`Message from Bot: ${answer}`);
-        setIsSendButtonDisabled(false);
-      };
-      const reject = () => {
-        log.debug("Rejected");
-        setIsSendButtonDisabled(true);
-        const newMessages = [];
-        newMessages.push(...messages);
-        newMessages.push(aiService.createUserMessage(username, "Rejected"));
-        setMessages(newMessages);
-        setIsSendButtonDisabled(false);
-      };
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_core2.Flex, { columnGap: { default: "columnGapSm" }, children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_core2.Button, { variant: "primary", onClick: () => approve(toolCalls), children: "Approve" }),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_core2.Button, { variant: "secondary", onClick: reject, children: "Reject" })
-      ] });
-    };
-  }
-});
-
-// src/ai-plugin/jmx-ai/JmxContent.css
-var init_JmxContent = __esm({
-  "src/ai-plugin/jmx-ai/JmxContent.css"() {
-  }
-});
-
-// src/ai-plugin/jmx-ai/util.ts
-function isObject(value) {
-  const type = typeof value;
-  return value != null && (type === "object" || type === "function");
-}
-function isNumber(value) {
-  return typeof value === "number" && !Number.isNaN(value);
-}
-function stringSorter(a, b, sortDesc) {
-  let res = a.localeCompare(b);
-  if (sortDesc) {
-    res *= -1;
-  }
-  return res;
-}
-function objectSorter(aValue, bValue, sortDesc) {
-  if (isNumber(aValue)) {
-    if (!sortDesc) {
-      return aValue - bValue;
-    }
-    return bValue - aValue;
-  } else {
-    return stringSorter(aValue, bValue, sortDesc);
-  }
-}
-function escapeMBean(mbean) {
-  return encodeURI(applyJolokiaEscapeRules(mbean));
-}
-function applyJolokiaEscapeRules(mbean) {
-  return mbean.replace(/!/g, "!!").replace(/\//g, "!/").replace(/"/g, '!"');
-}
-var init_util = __esm({
-  "src/ai-plugin/jmx-ai/util.ts"() {
-    "use strict";
-  }
-});
-
-// src/ai-plugin/jmx-ai/attributes/attribute-service.ts
-var import_react9, AttributeService, attributeService;
-var init_attribute_service = __esm({
-  "src/ai-plugin/jmx-ai/attributes/attribute-service.ts"() {
-    "use strict";
-    import_react9 = require("@hawtio/react");
-    init_globals();
-    init_util();
-    AttributeService = class {
-      handles = [];
-      requestOptions() {
-        return {};
-      }
-      setupConfig(request) {
-        return request;
-      }
-      async read(mbean) {
-        return await import_react9.jolokiaService.readAttributes(mbean, this.requestOptions());
-      }
-      async readWithCallback(mbean, callback) {
-        const attrs = await import_react9.jolokiaService.readAttributes(mbean, this.requestOptions());
-        callback(attrs);
-      }
-      async register(request, callback) {
-        const handle = await import_react9.jolokiaService.register(this.setupConfig(request), callback);
-        log.debug("Register handle:", handle);
-        this.handles.push(handle);
-      }
-      unregisterAll() {
-        log.debug("Unregister all handles:", this.handles);
-        this.handles.forEach((handle) => import_react9.jolokiaService.unregister(handle));
-        this.handles = [];
-      }
-      async buildUrl(mbean, attribute) {
-        const jolokiaUrl = await import_react9.jolokiaService.getFullJolokiaUrl();
-        return `${jolokiaUrl}/read/${escapeMBean(mbean)}/${attribute}`;
-      }
-      async canInvoke(mbean, attribute, type) {
-        return true;
-      }
-      async update(mbeanName, attribute, value) {
-        await import_react9.jolokiaService.writeAttribute(mbeanName, attribute, value, this.requestOptions());
-        import_react9.eventService.notify({ type: "success", message: `Updated attribute: ${attribute}` });
-      }
-      async bulkRequest(requests) {
-        return import_react9.jolokiaService.bulkRequest(requests.map(this.setupConfig));
-      }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ChatbotFooter.ChatbotFootnote, { label: "AI may be inaccurate. Please verify important information." })
+      ] });
     };
-    attributeService = new AttributeService();
-  }
-});
-
-// src/ai-plugin/jmx-ai/attributes/AttributeModal.tsx
-var import_react10, import_react_core3, import_react_icons, import_react11, import_jsx_runtime3;
-var init_AttributeModal = __esm({
-  "src/ai-plugin/jmx-ai/attributes/AttributeModal.tsx"() {
-    "use strict";
-    import_react10 = require("@hawtio/react");
-    import_react_core3 = require("@patternfly/react-core");
-    import_react_icons = require("@patternfly/react-icons");
-    import_react11 = require("react");
-    init_ai_service();
-    init_globals();
-    init_attribute_service();
-    import_jsx_runtime3 = require("react/jsx-runtime");
   }
 });
 
-// node_modules/jolokia.js/dist/jolokia.mjs
-function prepareRequest(request, agentOptions, params) {
-  const opts = Object.assign({}, agentOptions, { dataType: "json" }, params);
-  assertNotNull(opts.url, "No URL given");
-  const fetchOptions = Object.assign({}, DEFAULT_FETCH_PARAMS);
-  fetchOptions.headers = {};
-  const method = extractMethod(request, opts);
-  let url = ensureTrailingSlash(opts.url);
-  if (opts.headers) {
-    Object.assign(fetchOptions.headers, opts.headers);
-  }
-  if (method === "post") {
-    fetchOptions.method = "POST";
-    Object.assign(fetchOptions.headers, { "Content-Type": "text/json" });
-  } else {
-    fetchOptions.method = "GET";
-    url += constructGetUrlPath(request);
-  }
-  url = addProcessingParameters(url, opts);
-  if (opts.username && opts.password) {
-    if (typeof window.btoa === "function") {
-      fetchOptions.headers["Authorization"] = "Basic " + window.btoa(opts.username + ":" + opts.password);
-    } else {
-      console.warn(`Can't set "Authorization" header - no btoa() function available`);
-    }
-  }
-  if (opts.timeout != null) {
-    fetchOptions.signal = AbortSignal.timeout(opts.timeout);
-  }
-  let successCb = void 0;
-  let errorCb = void 0;
-  let fetchErrorCb = void 0;
-  if ("success" in opts) {
-    successCb = constructCallbackDispatcher(opts.success);
-    errorCb = constructCallbackDispatcher(opts.error);
-  }
-  if ("error" in opts && !opts.success) {
-    successCb = constructCallbackDispatcher("ignore");
-    errorCb = constructCallbackDispatcher(opts.error);
-  }
-  if (!("fetchError" in opts)) {
-    if (successCb && errorCb) {
-      fetchErrorCb = (_response, reason) => {
-        console.warn(reason);
-      };
-    }
-  } else if (opts.fetchError === "ignore") {
-    fetchErrorCb = (_response, _reason) => {
-    };
-  } else {
-    fetchErrorCb = opts.fetchError;
-  }
-  return { url, fetchOptions, dataType: opts.dataType, resolve: opts.resolve, successCb, errorCb, fetchErrorCb };
-}
-async function performRequest(args) {
-  const { url, fetchOptions, dataType, resolve, successCb, errorCb, fetchErrorCb } = args;
-  if (successCb && errorCb) {
-    return fetch(url, fetchOptions).then(async (response) => {
-      if (response.status != 200) {
-        fetchErrorCb?.(response, response.statusText);
-        return void 0;
-      }
-      const ct = response.headers.get("content-type");
-      if (dataType === "text" || !ct || !(ct.startsWith("text/json") || ct.startsWith("application/json"))) {
-        const textResponse = await response.text();
-        void successCb(textResponse);
-      } else {
-        const jsonResponse = await response.json();
-        const responses = Array.isArray(jsonResponse) ? jsonResponse : [jsonResponse];
-        for (let n = 0; n < responses.length; n++) {
-          const resp = responses[n];
-          if (Jolokia.isError(resp)) {
-            errorCb(resp, n);
-          } else {
-            successCb(resp, n);
-          }
-        }
-      }
-    }).catch((reason) => {
-      fetchErrorCb?.(null, reason);
-      return void 0;
-    });
-  } else {
-    if (resolve === "response") {
-      return fetch(url, fetchOptions);
-    } else {
-      const promise = fetch(url, fetchOptions).then(async (response) => {
-        if (response.status != 200) {
-          throw response;
-        }
-        const ct = response.headers.get("content-type");
-        if (dataType === "text" || !ct || !(ct.startsWith("text/json") || ct.startsWith("application/json"))) {
-          return response.text();
-        }
-        return response.json();
-      });
-      if (fetchErrorCb) {
-        return promise.catch((error) => {
-          if (error instanceof Response) {
-            fetchErrorCb(error, null);
-          } else {
-            fetchErrorCb(null, error);
-          }
-          return void 0;
-        });
-      } else {
-        return promise;
-      }
-    }
-  }
-}
-function constructCallbackDispatcher(cb) {
-  if (!cb || Array.isArray(cb) && cb.length == 0) {
-    return (response, index) => {
-      let r;
-      if (typeof response === "string") {
-        r = response;
-      } else {
-        r = JSON.stringify(response);
-      }
-      if (r && r.length > 256) {
-        r = r.substring(0, 253) + "...";
-      }
-      console.warn("Ignore response", '"' + r + '"', "index=", index);
-    };
-  }
-  if (cb === "ignore") {
-    return () => {
-    };
-  }
-  const cbArray = Array.isArray(cb) ? cb : [cb];
-  return (response, index) => {
-    if (typeof response === "string") {
-      cbArray[0](response);
-    } else {
-      cbArray[index % cbArray.length](response, index);
-    }
-  };
-}
-function createJolokiaInvocation(jobs, agentOptions) {
-  const requestArguments = prepareRequest([], agentOptions, { method: "post" });
-  return function() {
-    const successCbs = [];
-    const errorCbs = [];
-    const requests = [];
-    const indexMapping = [];
-    const fetchErrorCbs = [];
-    for (const [jobId, job] of jobs) {
-      const reqsLen = job.requests.length;
-      if (job.success) {
-        const successCb = constructSuccessJobCallback(job, jobId, indexMapping);
-        const errorCb = constructErrorJobCallback(job, jobId, indexMapping);
-        for (let idx = 0; idx < reqsLen; idx++) {
-          requests.push(prepareJobRequest(job, idx));
-          successCbs.push(successCb);
-          errorCbs.push(errorCb);
-          indexMapping.push(idx);
-        }
-        if (job.fetchError) {
-          fetchErrorCbs.push(job.fetchError);
-        }
-      } else if (job.callback) {
-        const callbackConfiguration = constructJobCallbackConfiguration(job, jobId);
-        for (let idx = 0; idx < reqsLen - 1; idx++) {
-          requests.push(prepareJobRequest(job, idx));
-          successCbs.push(callbackConfiguration.cb);
-          errorCbs.push(callbackConfiguration.cb);
-          indexMapping.push(-1);
-        }
-        requests.push(prepareJobRequest(job, reqsLen - 1));
-        successCbs.push(callbackConfiguration.lcb);
-        errorCbs.push(callbackConfiguration.lcb);
-        indexMapping.push(-1);
-        const cb = (response, error) => {
-          job.callback(response ?? error);
-        };
-        fetchErrorCbs.push(cb);
-      }
-    }
-    if (requests.length > 0) {
-      requestArguments.fetchOptions.body = JSON.stringify(requests);
-      requestArguments.successCb = function(response, index) {
-        successCbs[index](response, index);
-      };
-      requestArguments.errorCb = function(response, index) {
-        errorCbs[index](response, index);
-      };
-      requestArguments.fetchErrorCb = function(response, error) {
-        if (fetchErrorCbs.length > 0) {
-          fetchErrorCbs.forEach((cb) => {
-            cb(response, error);
-          });
-        } else {
-          if (response) {
-            console.error("Problem executing registered jobs: ", response.status, response.statusText);
-          } else {
-            console.error("Problem executing registered jobs: ", error);
-          }
-        }
-      };
-      performRequest(requestArguments).catch((e) => {
-        console.warn("Problem invoking a poller", e);
-      });
-    }
-  };
-}
-function constructSuccessJobCallback(job, jobId, indexMapping) {
-  if (!job.success) {
-    throw "Expected 'success' callback configured for the job with ID=" + jobId;
-  }
-  return function(response, index) {
-    if (job.onlyIfModified) {
-      job.lastModified = response.timestamp;
-    }
-    job.success(response, jobId, indexMapping[index]);
-  };
-}
-function constructErrorJobCallback(job, jobId, indexMapping) {
-  if (!job.error) {
-    throw "Expected 'error' callback configured for the job with ID=" + jobId;
-  }
-  return function(response, index) {
-    if (response.status === 304) {
-      return;
-    } else {
-      job.error(response, jobId, indexMapping[index]);
-    }
-  };
-}
-function constructJobCallbackConfiguration(job, jobId) {
-  if (!job.callback) {
-    throw "Expected 'callback' configured for the job with ID=" + jobId;
-  }
-  const allResponses = [];
-  let lastModified = 0;
-  return {
-    cb: addResponse,
-    lcb: function(response, index) {
-      addResponse(response);
-      if (allResponses.length > 0) {
-        job.lastModified = lastModified;
-        job.callback(...allResponses);
-      }
-    }
-  };
-  function addResponse(response, _index) {
-    if (response.status !== 304) {
-      if (lastModified === 0 || response.timestamp && response.timestamp < lastModified) {
-        if (response.timestamp) {
-          lastModified = response.timestamp;
-        }
-      }
-      allResponses.push(response);
-    }
-  }
-}
-function prepareJobRequest(job, requestIndex) {
-  const request = job.requests[requestIndex];
-  const config = job.config || {};
-  const extraConfig = job.onlyIfModified && job.lastModified ? { ifModifiedSince: job.lastModified } : {};
-  request.config = Object.assign({}, config, request.config, extraConfig);
-  return request;
-}
-function assertNotNull(value, message) {
-  if (value == null) {
-    throw new Error(message);
-  }
-}
-function extractMethod(request, params) {
-  const methodGiven = params?.method?.toLowerCase();
-  let method;
-  if (!request) {
-    return "get";
-  }
-  if (methodGiven) {
-    if (methodGiven === "get") {
-      if (Array.isArray(request)) {
-        throw new Error("Cannot use GET with bulk requests");
-      }
-      if (request.type?.toLowerCase() === "read" && "attribute" in request && Array.isArray(request.attribute)) {
-        throw new Error("Cannot use GET for read with multiple attributes");
-      }
-      if ("target" in request) {
-        throw new Error("Cannot use GET request with proxy mode");
-      }
-      if ("config" in request) {
-        throw new Error("Cannot use GET with request specific config");
-      }
-      method = "get";
-    } else if (methodGiven !== "post") {
-      throw new Error('Illegal method "' + methodGiven + '"');
-    } else {
-      method = "post";
-    }
-  } else {
-    if (Array.isArray(request) || "config" in request || request.type?.toLowerCase() === "read" && "attribute" in request && Array.isArray(request.attribute) || "target" in request) {
-      method = "post";
-    } else {
-      method = "get";
-    }
-  }
-  return method;
-}
-function ensureTrailingSlash(url) {
-  const v = typeof url === "string" ? url : url.href;
-  let trimEnd = v.length;
-  while (v[trimEnd - 1] === "/") {
-    trimEnd--;
-  }
-  return v.substring(0, trimEnd) + "/";
-}
-function addProcessingParameters(url, opts) {
-  let sep = url.indexOf("?") > 0 ? "&" : "?";
-  PROCESSING_PARAMS.forEach(function(key) {
-    const v = opts[key];
-    if (v != null) {
-      url += sep + key + "=" + v;
-      sep = "&";
-    }
-  });
-  return url;
-}
-function valueToString(value) {
-  if (value == null) {
-    return "[null]";
-  }
-  if (Array.isArray(value)) {
-    let ret = "";
-    for (let i = 0; i < value.length; i++) {
-      const v = value[i];
-      ret += v == null ? "[null]" : singleValueToString(value[i]);
-      if (i < value.length - 1) {
-        ret += ",";
-      }
-    }
-    return ret;
-  } else {
-    return singleValueToString(value);
-  }
-}
-function singleValueToString(value) {
-  if (typeof value === "string" && value.length === 0) {
-    return '""';
-  } else {
-    return value.toString();
-  }
-}
-function constructGetUrlPath(request) {
-  let type = request.type;
-  assertNotNull(type, "No request type given for building a GET request");
-  type = type.toLowerCase();
-  const extractor = GET_URL_EXTRACTORS[type];
-  assertNotNull(extractor, "Unknown request type " + type);
-  const result = extractor(request);
-  const parts = result.parts || [];
-  let url = type;
-  parts.forEach(function(v) {
-    url += "/" + Jolokia.escape(v);
-  });
-  if (result.path) {
-    url += (result.path[0] === "/" ? "" : "/") + result.path;
-  }
-  return url;
-}
-function extractNotificationMode(client, opts) {
-  const backends = client.backend || {};
-  let mode = opts.mode;
-  if (!mode) {
-    mode = backends["sse"] ? "sse" : backends["pull"] ? "pull" : void 0;
-    if (!mode && backends.length === 1) {
-      return Object.keys(backends)[0];
-    }
-  }
-  if (!mode || !backends[mode]) {
-    throw new Error("Notification mode must be one of [" + Object.keys(backends) + "]" + (mode ? ', and not "' + mode + '"' : ""));
-  }
-  return mode;
-}
-var CLIENT_VERSION, DEFAULT_FETCH_PARAMS, PROCESSING_PARAMS, Jolokia, GET_URL_EXTRACTORS;
-var init_jolokia = __esm({
-  "node_modules/jolokia.js/dist/jolokia.mjs"() {
+// src/ai-plugin/chat/Chat.tsx
+var import_Chatbot2, import_react_core5, import_jsx_runtime5, Chat;
+var init_Chat2 = __esm({
+  "src/ai-plugin/chat/Chat.tsx"() {
     "use strict";
-    CLIENT_VERSION = "2.6.0";
-    DEFAULT_FETCH_PARAMS = {
-      cache: "no-store",
-      credentials: "same-origin",
-      redirect: "error"
-    };
-    PROCESSING_PARAMS = [
-      "maxDepth",
-      "maxCollectionSize",
-      "maxObjects",
-      "serializeLong",
-      "ignoreErrors",
-      "includeStackTrace",
-      "serializeException",
-      "canonicalNaming",
-      "mimeType",
-      "includeRequest",
-      "ifModifiedSince",
-      "listCache"
-    ];
-    Jolokia = function(config) {
-      if (!new.target) {
-        return new Jolokia(config);
-      }
-      const jobs = /* @__PURE__ */ new Map();
-      let jobId = 1;
-      let client;
-      const agentOptions = {};
-      let pollerIsRunning = false;
-      let timerId = null;
-      if (typeof config === "string") {
-        config = { url: config };
-      }
-      Object.assign(agentOptions, DEFAULT_FETCH_PARAMS, config);
-      this.request = async function(request, params) {
-        const args = prepareRequest(request, agentOptions, params);
-        if (args.fetchOptions.method === "POST") {
-          args.fetchOptions.body = JSON.stringify(request);
-        }
-        return performRequest(args);
-      };
-      this.register = function(jobInfo, ...requests) {
-        if (!requests || requests.length == 0) {
-          throw "At a least one request must be provided";
-        }
-        const job = { requests };
-        if (typeof jobInfo === "function") {
-          job.callback = jobInfo;
-        } else {
-          if ("callback" in jobInfo) {
-            job.callback = jobInfo.callback;
-          } else if ("success" in jobInfo && "error" in jobInfo) {
-            job.success = jobInfo.success;
-            job.error = jobInfo.error;
-            job.fetchError = jobInfo.fetchError;
-          } else {
-            throw "Either 'callback' or ('success' and 'error') callback must be provided when registering a Jolokia job";
-          }
-          job.config = jobInfo.config;
-          job.onlyIfModified = jobInfo.onlyIfModified;
-        }
-        return addJob(job);
-      };
-      this.unregister = function(handle) {
-        jobs.delete(handle);
-      };
-      this.jobs = function() {
-        return [...jobs.keys()];
-      };
-      this.start = function(interval) {
-        interval = interval || agentOptions.fetchInterval || 3e4;
-        if (pollerIsRunning) {
-          if (interval === agentOptions.fetchInterval) {
-            return;
-          }
-          this.stop();
-        }
-        agentOptions.fetchInterval = interval;
-        timerId = setInterval(createJolokiaInvocation(jobs, agentOptions), interval);
-        pollerIsRunning = true;
-      };
-      this.stop = function() {
-        if (!pollerIsRunning || !timerId) {
-          return;
-        }
-        clearInterval(timerId);
-        timerId = null;
-        pollerIsRunning = false;
-      };
-      this.isRunning = function() {
-        return pollerIsRunning;
-      };
-      this.addNotificationListener = async function(opts) {
-        await ensureNotificationRegistration(this);
-        const mode = extractNotificationMode(client, opts);
-        notificationHandlerFunc("lazy-init", mode)();
-        return await this.request({
-          type: "notification",
-          command: "add",
-          mode,
-          client: client.id,
-          mbean: opts.mbean,
-          filter: opts.filter,
-          config: opts.config,
-          handback: opts.handback
-        }, { method: "post" }).then((responses) => {
-          const resp = responses;
-          if (Jolokia.isError(resp)) {
-            throw new Error("Cannot not add notification subscription for " + opts.mbean + " (client: " + client.id + "): " + resp.error);
-          }
-          const handle = {
-            id: resp.value,
-            mode
-          };
-          notificationHandlerFunc("add", mode)(this, handle, opts);
-          return handle;
-        });
-      };
-      this.removeNotificationListener = async function(handle) {
-        notificationHandlerFunc("remove", handle.mode)(this, handle);
-        return await this.request({
-          type: "notification",
-          command: "remove",
-          client: client.id,
-          handle: handle.id
-        }, { method: "post" }).then((responses) => {
-          const resp = responses;
-          return !Jolokia.isError(resp);
-        });
-      };
-      this.unregisterNotificationClient = async function() {
-        const backends = client.backend || {};
-        for (const mode in NOTIFICATION_HANDLERS) {
-          if (NOTIFICATION_HANDLERS[mode] && backends[mode]) {
-            notificationHandlerFunc("unregister", mode)();
-          }
-        }
-        return await this.request({
-          type: "notification",
-          command: "unregister",
-          client: client.id
-        }, { method: "post" }).then((responses) => {
-          const resp = responses;
-          return !Jolokia.isError(resp);
-        });
-      };
-      function addJob(job) {
-        const id = jobId++;
-        jobs.set(id, job);
-        setTimeout(() => {
-          const newJobMap = /* @__PURE__ */ new Map();
-          newJobMap.set(id, job);
-          const jobFunction = createJolokiaInvocation(newJobMap, agentOptions);
-          jobFunction();
-        }, 0);
-        return id;
-      }
-      async function ensureNotificationRegistration(jolokia) {
-        if (!client) {
-          return jolokia.request({
-            type: "notification",
-            command: "register"
-          }, { method: "post" }).then((responses) => {
-            const resp = responses;
-            if (Jolokia.isError(resp)) {
-              throw new Error("Can not register client for notifications: " + resp.error + "\nTrace:\n" + resp.stacktrace);
-            } else {
-              client = resp.value;
-            }
-            return true;
-          });
-        } else {
-          return Promise.resolve(true);
-        }
-      }
-      function notificationHandlerFunc(what, mode) {
-        const notifHandler = NOTIFICATION_HANDLERS[mode];
-        if (!notifHandler) {
-          throw new Error("Unsupported notification mode '" + mode + "'");
-        }
-        return function(jolokia, handle, opts) {
-          return notifHandler[what]?.apply(notifHandler, [jolokia, handle, opts]);
-        };
-      }
-      const NOTIFICATION_HANDLERS = {
-        "pull": {
-          // "pull" handler is based on server-side MBean instance collecting notifications for all registered
-          // clients. In order to get the notifications, we have to call this MBean's "pull" operation, passing
-          // client ID and handle ID
-          // --- operations of pull notification mechanism
-          add: function(_jolokia, handle, opts) {
-            const job = {
-              callback: function(resp) {
-                if (!Jolokia.isResponseFetchError(resp) && !Jolokia.isError(resp)) {
-                  const notifs = resp.value;
-                  if (notifs && notifs.notifications && notifs.notifications.length > 0) {
-                    opts?.callback?.(notifs);
-                  }
-                }
-              },
-              requests: [{
-                type: "exec",
-                mbean: client.backend["pull"].store,
-                operation: "pull",
-                arguments: [client.id, handle.id]
-              }]
-            };
-            this.jobIds[handle.id] = addJob(job);
-          },
-          remove: function(jolokia, handle) {
-            const job = this.jobIds[handle.id];
-            if (job != void 0) {
-              jolokia.unregister(job);
-              delete this.jobIds[handle.id];
-            }
-          },
-          unregister: function(jolokia) {
-            for (const handleId in this.jobIds) {
-              if (this.jobIds[handleId] != void 0) {
-                jolokia.unregister(this.jobIds[handleId]);
-              }
-            }
-            this.jobIds = {};
-          },
-          // --- state of pull notification mechanism
-          jobIds: {}
-        },
-        "sse": {
-          // "sse" handler is based on https://developer.mozilla.org/en-US/docs/Web/API/EventSource
-          // and continuous stream of events sent over single HTTP connection with text/event-stream MIME type
-          // the messages sent are JSON representations of org.jolokia.server.core.service.notification.NotificationResult instances
-          // --- operations of sse notification mechanism
-          "lazy-init": function() {
-            if (!this.eventSource) {
-              this.eventSource = new EventSource(agentOptions.url + "/notification/open/" + client.id + "/sse");
-              const dispatchers = this.dispatchMap;
-              this.eventSource.addEventListener("message", function(event) {
-                const data = JSON.parse(event.data);
-                if (data.handle) {
-                  const callback = dispatchers[data.handle];
-                  callback?.(data);
-                }
-              });
-            }
-          },
-          add: function(_jolokia, handle, opts) {
-            this.dispatchMap[handle.id] = opts.callback;
-          },
-          remove: function(_jolokia, handle) {
-            delete this.dispatchMap[handle.id];
-          },
-          unregister: function() {
-            this.dispatchMap = {};
-            this.eventSource?.close();
-            this.eventSource = null;
-          },
-          // --- state of sse notification mechanism
-          // Map for dispatching SSE return notifications
-          dispatchMap: {},
-          // SSE event-source
-          eventSource: null
-        }
-      };
+    import_Chatbot2 = require("@patternfly/chatbot/dist/dynamic/Chatbot");
+    import_react_core5 = require("@patternfly/react-core");
+    init_Chat();
+    init_ChatbotPanel();
+    init_context();
+    import_jsx_runtime5 = require("react/jsx-runtime");
+    Chat = () => {
+      const chatbotContext = useChatbot();
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ChatbotContext.Provider, { value: chatbotContext, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.PageSection, { id: "chat-content", hasBodyWrapper: false, isFilled: true, padding: { default: "noPadding" }, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ChatbotPanel, { title: "AI Chat", displayMode: import_Chatbot2.ChatbotDisplayMode.embedded }) }) });
     };
-    Object.defineProperty(Jolokia.prototype, "CLIENT_VERSION", {
-      value: CLIENT_VERSION,
-      enumerable: true,
-      writable: false
+  }
+});
+
+// src/ai-plugin/chat/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  Chat: () => Chat
+});
+var init_ui = __esm({
+  "src/ai-plugin/chat/ui.ts"() {
+    "use strict";
+    init_Chat2();
+  }
+});
+
+// src/ai-plugin/jmx-ai/globals.ts
+var import_react12, pluginName3, pluginTitle3, pluginPath2, log3, PARAM_KEY_NODE_ID;
+var init_globals3 = __esm({
+  "src/ai-plugin/jmx-ai/globals.ts"() {
+    "use strict";
+    import_react12 = require("@hawtio/react");
+    pluginName3 = "hawtio-ai-jmx";
+    pluginTitle3 = "AI JMX";
+    pluginPath2 = "/ai-jmx";
+    log3 = import_react12.Logger.get(pluginName3);
+    PARAM_KEY_NODE_ID = "nid";
+  }
+});
+
+// src/ai-plugin/jmx-ai/context.ts
+function useMBeanTree() {
+  const [tree, setTree] = (0, import_react14.useState)(import_react13.MBeanTree.createEmpty(pluginName3));
+  const [loaded, setLoaded] = (0, import_react14.useState)(false);
+  const { selectedNode, setSelectedNode } = (0, import_react14.useContext)(import_react13.PluginNodeSelectionContext);
+  const navigate = (0, import_react_router.useNavigate)();
+  const [searchParams, setSearchParams] = (0, import_react_router.useSearchParams)();
+  const refSelectedNode = (0, import_react14.useRef)();
+  refSelectedNode.current = selectedNode;
+  const populateTree = async () => {
+    const wkspTree = await import_react13.workspace.getTree();
+    setTree(wkspTree);
+    const nodeId = searchParams.get(PARAM_KEY_NODE_ID);
+    if (nodeId && nodeId !== refSelectedNode.current?.id) {
+      log3.debug("Restore selected node with nid:", nodeId);
+      const urlNode = wkspTree.find((node) => node.id === nodeId);
+      if (urlNode) {
+        setSelectedNode(urlNode);
+        refSelectedNode.current = urlNode;
+      } else {
+        log3.debug("Clear invalid nid:", nodeId);
+        searchParams.delete(PARAM_KEY_NODE_ID);
+        setSearchParams(searchParams);
+      }
+    }
+    if (!refSelectedNode.current) return;
+    const path = [...refSelectedNode.current.path()];
+    wkspTree.forEach(path, (node) => {
+      node.defaultExpanded = true;
     });
-    Jolokia.escape = Jolokia.prototype.escape = function(part) {
-      return encodeURIComponent(part.replace(/!/g, "!!").replace(/\//g, "!/"));
-    };
-    Jolokia.escapePost = Jolokia.prototype.escape = function(part) {
-      return part.replace(/!/g, "!!").replace(/\//g, "!/");
-    };
-    Jolokia.isError = Jolokia.prototype.isError = function(resp) {
-      return resp == null || resp.status != 200;
-    };
-    Jolokia.isResponseSuccess = function(resp) {
-      if (!resp || typeof resp !== "object")
-        return false;
-      return "status" in resp && "timestamp" in resp && "value" in resp;
-    };
-    Jolokia.isResponseError = function(resp) {
-      if (!resp || typeof resp !== "object")
-        return false;
-      return "error_type" in resp && "error" in resp;
+    const newSelected = wkspTree.navigate(...path);
+    if (newSelected) {
+      setSelectedNode(newSelected);
+      navigate(pluginPathWithNodeId(newSelected, searchParams));
+    } else {
+      navigate(pluginPath2);
+    }
+  };
+  (0, import_react14.useEffect)(() => {
+    const loadTree = async () => {
+      await populateTree();
+      setLoaded(true);
     };
-    Jolokia.isResponseFetchError = function(resp) {
-      if (resp instanceof Response) {
-        return resp.status >= 400;
-      }
-      if (resp instanceof DOMException || resp instanceof TypeError) {
-        return true;
-      }
-      return false;
+    const listener = () => {
+      setLoaded(false);
+      loadTree();
     };
-    GET_URL_EXTRACTORS = {
-      /**
-       * Function to prepare GET URL for `read` Jolokia request
-       * @param request Jolokia request object
-       * @returns URL configuration object for Jolokia `read` GET request
-       */
-      "read": function(request) {
-        const path = Array.isArray(request.path) ? request.path.map(Jolokia.escape).join("/") : request.path;
-        if (request.attribute == null) {
-          return { parts: [request.mbean, "*"], path };
-        } else {
-          return { parts: [request.mbean, request.attribute], path };
-        }
-      },
-      /**
-       * Function to prepare GET URL for `write` Jolokia request
-       * @param request Jolokia request object
-       * @returns URL configuration object for Jolokia `write` GET request
-       */
-      "write": function(request) {
-        const path = Array.isArray(request.path) ? request.path.map(Jolokia.escape).join("/") : request.path;
-        return { parts: [request.mbean, request.attribute, valueToString(request.value)], path };
-      },
-      /**
-       * Function to prepare GET URL for `exec` Jolokia request
-       * @param request Jolokia request object
-       * @returns URL configuration object for Jolokia `exec` GET request
-       */
-      "exec": function(request) {
-        const ret = [request.mbean, request.operation];
-        if (request.arguments && request.arguments.length > 0) {
-          request.arguments.forEach(function(value) {
-            ret.push(valueToString(value));
-          });
-        }
-        return { parts: ret };
-      },
-      /**
-       * Function to prepare GET URL for `version` Jolokia request
-       * @param _request Jolokia request object
-       * @returns URL configuration object for Jolokia `version` GET request
-       */
-      "version": function(_request) {
-        return {};
-      },
-      /**
-       * Function to prepare GET URL for `search` Jolokia request
-       * @param request Jolokia request object
-       * @returns URL configuration object for Jolokia `search` GET request
-       */
-      "search": function(request) {
-        return { parts: [request.mbean] };
-      },
-      /**
-       * Function to prepare GET URL for `list` Jolokia request
-       * @param request Jolokia request object
-       * @returns URL configuration object for Jolokia `list` GET request
-       */
-      "list": function(request) {
-        return { path: request.path };
-      },
-      /**
-       * Function to prepare GET URL for `notification` Jolokia request
-       * @param request Jolokia request object
-       * @returns URL configuration object for Jolokia `notification` GET request
-       */
-      "notification": function(request) {
-        switch (request.command) {
-          case "register":
-            return { parts: ["register"] };
-          case "add": {
-            const ret = ["add", valueToString(request.client), valueToString(request.mode), valueToString(request.mbean)];
-            const extra = [];
-            if (request.handback) {
-              extra.push(valueToString(request.handback));
-            }
-            if (request.config) {
-              extra.push(valueToString(request.config));
-            } else if (extra.length) {
-              extra.push("{}");
-            }
-            if (request.filter) {
-              extra.push(valueToString(request.filter));
-            } else if (extra.length) {
-              extra.push(" ");
-            }
-            return { parts: ret.concat(extra.reverse()) };
-          }
-          case "remove":
-            return { parts: ["remove", valueToString(request.client), valueToString(request.handle)] };
-          case "unregister":
-            return { parts: ["unregister", valueToString(request.client)] };
-          case "list":
-            return { parts: ["list", valueToString(request.client)] };
-          case "ping":
-            return { parts: ["ping", valueToString(request.client)] };
-          case "open":
-            return { parts: ["open", valueToString(request.client), valueToString(request.mode)] };
-          default:
-            throw new Error("Unknown command '" + request.command + "'");
-        }
+    import_react13.eventService.onRefresh(listener);
+    loadTree();
+    return () => import_react13.eventService.removeListener(import_react13.EVENT_REFRESH, listener);
+  }, []);
+  return { tree, loaded, selectedNode, setSelectedNode };
+}
+function pluginPathWithNodeId(node, searchParams = new URLSearchParams(window.location.search)) {
+  searchParams.set(PARAM_KEY_NODE_ID, node.id);
+  const query = `?${searchParams.toString()}`;
+  return { pathname: pluginPath2, search: query };
+}
+var import_react13, import_react14, import_react_router, MBeanTreeContext;
+var init_context2 = __esm({
+  "src/ai-plugin/jmx-ai/context.ts"() {
+    "use strict";
+    import_react13 = require("@hawtio/react");
+    import_react14 = require("react");
+    import_react_router = require("react-router");
+    init_globals3();
+    MBeanTreeContext = (0, import_react14.createContext)({
+      tree: import_react13.MBeanTree.createEmpty(pluginName3),
+      loaded: false,
+      selectedNode: null,
+      setSelectedNode: () => {
       }
-    };
+    });
+  }
+});
+
+// src/ai-plugin/jmx-ai/Jmx.css
+var init_Jmx = __esm({
+  "src/ai-plugin/jmx-ai/Jmx.css"() {
+  }
+});
+
+// src/ai-plugin/jmx-ai/JmxContent.css
+var init_JmxContent = __esm({
+  "src/ai-plugin/jmx-ai/JmxContent.css"() {
   }
 });
 
@@ -3252,35 +1180,127 @@ What potential issues or anomalies do you see?`;
   }
 });
 
+// src/ai-plugin/jmx-ai/util.ts
+function isObject(value) {
+  const type = typeof value;
+  return value != null && (type === "object" || type === "function");
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+function stringSorter(a, b, sortDesc) {
+  let res = a.localeCompare(b);
+  if (sortDesc) {
+    res *= -1;
+  }
+  return res;
+}
+function objectSorter(aValue, bValue, sortDesc) {
+  if (isNumber(aValue)) {
+    if (!sortDesc) {
+      return aValue - bValue;
+    }
+    return bValue - aValue;
+  } else {
+    return stringSorter(aValue, bValue, sortDesc);
+  }
+}
+function escapeMBean(mbean) {
+  return encodeURI(applyJolokiaEscapeRules(mbean));
+}
+function applyJolokiaEscapeRules(mbean) {
+  return mbean.replace(/!/g, "!!").replace(/\//g, "!/").replace(/"/g, '!"');
+}
+var init_util = __esm({
+  "src/ai-plugin/jmx-ai/util.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai-plugin/jmx-ai/attributes/attribute-service.ts
+var import_react15, AttributeService, attributeService;
+var init_attribute_service = __esm({
+  "src/ai-plugin/jmx-ai/attributes/attribute-service.ts"() {
+    "use strict";
+    import_react15 = require("@hawtio/react");
+    init_globals3();
+    init_util();
+    AttributeService = class {
+      handles = [];
+      requestOptions() {
+        return {};
+      }
+      setupConfig(request) {
+        return request;
+      }
+      async read(mbean) {
+        return await import_react15.jolokiaService.readAttributes(mbean, this.requestOptions());
+      }
+      async readWithCallback(mbean, callback) {
+        const attrs = await import_react15.jolokiaService.readAttributes(mbean, this.requestOptions());
+        callback(attrs);
+      }
+      async register(request, callback) {
+        const handle = await import_react15.jolokiaService.register(this.setupConfig(request), callback);
+        log3.debug("Register handle:", handle);
+        this.handles.push(handle);
+      }
+      unregisterAll() {
+        log3.debug("Unregister all handles:", this.handles);
+        this.handles.forEach((handle) => import_react15.jolokiaService.unregister(handle));
+        this.handles = [];
+      }
+      async buildUrl(mbean, attribute) {
+        const jolokiaUrl = await import_react15.jolokiaService.getFullJolokiaUrl();
+        return `${jolokiaUrl}/read/${escapeMBean(mbean)}/${attribute}`;
+      }
+      async canInvoke(mbean, attribute, type) {
+        return true;
+      }
+      async update(mbeanName, attribute, value) {
+        await import_react15.jolokiaService.writeAttribute(mbeanName, attribute, value, this.requestOptions());
+        import_react15.eventService.notify({ type: "success", message: `Updated attribute: ${attribute}` });
+      }
+      async bulkRequest(requests) {
+        return import_react15.jolokiaService.bulkRequest(requests.map(this.setupConfig));
+      }
+    };
+    attributeService = new AttributeService();
+  }
+});
+
 // src/ai-plugin/jmx-ai/attributes/Attributes.tsx
-var import_react12, import_ui2, import_react_core4, import_react_icons2, import_react_table, import_react13, import_jsx_runtime4, Attributes, AiJmxToolbar;
+var import_react16, import_ui3, import_react_core7, import_react_icons, import_react_table2, import_jolokia, import_react17, import_jsx_runtime7, Attributes, AiJmxToolbar;
 var init_Attributes = __esm({
   "src/ai-plugin/jmx-ai/attributes/Attributes.tsx"() {
     "use strict";
-    import_react12 = require("@hawtio/react");
-    import_ui2 = require("@hawtio/react/ui");
-    import_react_core4 = require("@patternfly/react-core");
-    import_react_icons2 = require("@patternfly/react-icons");
-    import_react_table = require("@patternfly/react-table");
-    init_jolokia();
-    import_react13 = require("react");
-    init_ai_service();
+    import_react16 = require("@hawtio/react");
+    import_ui3 = require("@hawtio/react/ui");
+    import_react_core7 = require("@patternfly/react-core");
+    import_react_icons = require("@patternfly/react-icons");
+    import_react_table2 = require("@patternfly/react-table");
+    import_jolokia = __toESM(require("jolokia.js"));
+    import_react17 = require("react");
     init_context();
-    init_DiagnosisChatbot();
-    init_globals();
+    init_ThinkInfo();
+    init_ToolCallsApprove();
+    init_ToolCallsInfo();
+    init_ai_service();
+    init_context2();
+    init_globals3();
     init_jmx_ai_service();
     init_util();
     init_attribute_service();
-    import_jsx_runtime4 = require("react/jsx-runtime");
+    import_jsx_runtime7 = require("react/jsx-runtime");
     Attributes = () => {
-      const { selectedNode } = (0, import_react13.useContext)(MBeanTreeContext);
-      const [attributes, setAttributes] = (0, import_react13.useState)({});
-      const [isReading, setIsReading] = (0, import_react13.useState)(true);
-      const [isModalOpen, setIsModalOpen] = (0, import_react13.useState)(false);
-      const [sortDirection, setSortDirection] = (0, import_react13.useState)("asc");
-      const [selected, setSelected] = (0, import_react13.useState)({ name: "", value: "" });
-      const [reload, setReload] = (0, import_react13.useState)(false);
-      (0, import_react13.useEffect)(() => {
+      const { selectedNode } = (0, import_react17.useContext)(MBeanTreeContext);
+      const [attributes, setAttributes] = (0, import_react17.useState)({});
+      const [isReading, setIsReading] = (0, import_react17.useState)(true);
+      const [isModalOpen, setIsModalOpen] = (0, import_react17.useState)(false);
+      const [sortDirection, setSortDirection] = (0, import_react17.useState)("asc");
+      const [selected, setSelected] = (0, import_react17.useState)({ name: "", value: "" });
+      const [reload, setReload] = (0, import_react17.useState)(false);
+      (0, import_react17.useEffect)(() => {
         if (!selectedNode || !selectedNode.mbean || !selectedNode.objectName) {
           return;
         }
@@ -3293,14 +1313,14 @@ var init_Attributes = __esm({
         attributeService.register(
           { type: "read", mbean: objectName },
           (response) => {
-            if (response && !Jolokia.isError(response)) {
+            if (response && !import_jolokia.default.isError(response)) {
               setAttributes(response.value);
             }
           }
         );
         return () => attributeService.unregisterAll();
       }, [selectedNode]);
-      (0, import_react13.useEffect)(() => {
+      (0, import_react17.useEffect)(() => {
         if (!selectedNode || !selectedNode.mbean || !selectedNode.objectName || !reload) {
           return;
         }
@@ -3316,14 +1336,14 @@ var init_Attributes = __esm({
         return null;
       }
       if (isReading) {
-        return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react12.HawtioLoadingCard, {});
+        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react16.HawtioLoadingCard, {});
       }
       const rows = Object.entries(attributes).map(([name, value]) => ({
         name,
         value: isObject(value) ? JSON.stringify(value) : String(value)
       }));
       if (rows.length === 0) {
-        return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react12.HawtioEmptyCard, { message: "This MBean has no attributes." });
+        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react16.HawtioEmptyCard, { message: "This MBean has no attributes." });
       }
       const selectAttribute = (attribute) => {
         setSelected(attribute);
@@ -3343,8 +1363,8 @@ var init_Attributes = __esm({
         },
         columnIndex: 0
       });
-      const panelContent = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-        import_react12.AttributeModal,
+      const panelContent = /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+        import_react16.AttributeModal,
         {
           isOpen: isModalOpen,
           onClose: () => setIsModalOpen(false),
@@ -3352,34 +1372,34 @@ var init_Attributes = __esm({
           input: selected
         }
       );
-      const attributesTable = /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { id: "attribute-table-with-panel", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(AiJmxToolbar, { attributes }),
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_table.Table, { "aria-label": "Attributes", variant: "compact", children: [
-          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_table.Thead, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_table.Tr, { children: [
-            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_table.Th, { sort: getSortParams(), children: "Attribute" }),
-            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_table.Th, { children: "Value" })
+      const attributesTable = /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { id: "attribute-table-with-panel", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(AiJmxToolbar, { attributes }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_table2.Table, { "aria-label": "Attributes", variant: "compact", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_table2.Thead, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_table2.Tr, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_table2.Th, { sort: getSortParams(), children: "Attribute" }),
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_table2.Th, { children: "Value" })
           ] }) }),
-          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_table.Tbody, { children: rows.sort((a, b) => objectSorter(a.name, b.name, sortDirection === "desc")).map((att, index) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
-            import_react_table.Tr,
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_table2.Tbody, { children: rows.sort((a, b) => objectSorter(a.name, b.name, sortDirection === "desc")).map((att, index) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+            import_react_table2.Tr,
             {
               isClickable: true,
               isRowSelected: selected.name === att.name,
               onRowClick: () => selectAttribute(att),
               children: [
-                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_table.Td, { children: att.name }),
-                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_table.Td, { children: att.value })
+                /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_table2.Td, { children: att.name }),
+                /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_table2.Td, { children: att.value })
               ]
             },
             att.name + "-" + index
           )) })
         ] })
       ] });
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.Panel, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.Drawer, { isExpanded: isModalOpen, className: "pf-m-inline-on-2xl", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.DrawerContent, { panelContent, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.DrawerContentBody, { hasPadding: true, children: attributesTable }) }) }) });
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.Panel, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.Drawer, { isExpanded: isModalOpen, className: "pf-m-inline-on-2xl", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.DrawerContent, { panelContent, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.DrawerContentBody, { hasPadding: true, children: attributesTable }) }) }) });
     };
     AiJmxToolbar = ({ attributes }) => {
-      const { selectedNode } = (0, import_react13.useContext)(MBeanTreeContext);
-      const { username } = (0, import_react13.useContext)(import_ui2.PageContext);
-      const { setAnnouncement, setIsChatbotOpen, updateConversations } = (0, import_react13.useContext)(ChatbotContext);
+      const { selectedNode } = (0, import_react17.useContext)(MBeanTreeContext);
+      const { username } = (0, import_react17.useContext)(import_ui3.PageContext);
+      const { setAnnouncement, setIsChatbotOpen, updateConversations } = (0, import_react17.useContext)(ChatbotContext);
       if (!selectedNode || !selectedNode.mbean || !selectedNode.objectName) {
         return null;
       }
@@ -3387,7 +1407,7 @@ var init_Attributes = __esm({
       const diagnose = async () => {
         setIsChatbotOpen(true);
         const attrsValue = JSON.stringify(attributes);
-        log.debug("Attributes:", attrsValue);
+        log3.debug("Attributes:", attrsValue);
         const systemMessage = jmxAiService.systemMessage();
         const diagnoseMessage = jmxAiService.diagnoseMessage(objectName, attrsValue);
         const newMessages = [];
@@ -3395,19 +1415,19 @@ var init_Attributes = __esm({
         newMessages.push(aiService.createLoadingBotMessage());
         updateConversations(newMessages, `Diagnose ${objectName}`);
         setAnnouncement("Diagnosis in progress...");
-        log.debug("diagnose - new messages:", newMessages);
+        log3.debug("diagnose - new messages:", newMessages);
         const dialogId = newMessages[0].id;
-        const answer = await aiService.newChat(dialogId, diagnoseMessage, systemMessage);
+        const answer = await aiService.newChat(dialogId, { message: diagnoseMessage, system: systemMessage });
         const loadedMessages = [];
         loadedMessages.push(...newMessages);
-        log.debug("diagnose - loaded messages:", loadedMessages);
+        log3.debug("diagnose - loaded messages:", loadedMessages);
         loadedMessages.pop();
-        const botMessage = aiService.toBotMessage(answer, ThinkInfo, ToolCallsInfo, ToolCallsApprove);
+        const botMessage = aiService.toBotMessage(answer, false, ThinkInfo, ToolCallsInfo, ToolCallsApprove);
         loadedMessages.push(botMessage);
         updateConversations(loadedMessages);
         setAnnouncement("Diagnosis complete.");
       };
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.Toolbar, { id: "ai-jmx-toolbar", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.ToolbarContent, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.ToolbarItem, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_core4.Button, { variant: "primary", size: "sm", icon: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_icons2.MonitoringIcon, {}), onClick: diagnose, children: "Diagnose" }) }) }) });
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.Toolbar, { id: "ai-jmx-toolbar", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.ToolbarContent, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.ToolbarItem, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.Button, { variant: "primary", size: "sm", icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons.MonitoringIcon, {}), onClick: diagnose, children: "Diagnose" }) }) }) });
     };
   }
 });
@@ -3416,36 +1436,37 @@ var init_Attributes = __esm({
 var init_attributes = __esm({
   "src/ai-plugin/jmx-ai/attributes/index.ts"() {
     "use strict";
-    init_AttributeModal();
     init_Attributes();
   }
 });
 
 // src/ai-plugin/jmx-ai/JmxContent.tsx
-var import_react14, import_react_core5, import_popper_core, import_cubes_icon, import_react15, import_react_router_dom2, import_jsx_runtime5, JmxContent;
+var import_react18, import_Chatbot3, import_react_core8, import_popper_core, import_cubes_icon, import_react19, import_react_router2, import_jsx_runtime8, JmxContent;
 var init_JmxContent2 = __esm({
   "src/ai-plugin/jmx-ai/JmxContent.tsx"() {
     "use strict";
-    import_react14 = require("@hawtio/react");
-    import_react_core5 = require("@patternfly/react-core");
+    import_react18 = require("@hawtio/react");
+    import_Chatbot3 = require("@patternfly/chatbot/dist/dynamic/Chatbot");
+    import_react_core8 = require("@patternfly/react-core");
     import_popper_core = require("@patternfly/react-core/dist/esm/helpers/Popper/thirdparty/popper-core");
     import_cubes_icon = require("@patternfly/react-icons/dist/esm/icons/cubes-icon");
-    import_react15 = __toESM(require("react"));
-    import_react_router_dom2 = require("react-router-dom");
-    init_DiagnosisChatbot();
+    import_react19 = __toESM(require("react"));
+    import_react_router2 = require("react-router");
+    init_ChatbotPanel();
+    init_context();
     init_JmxContent();
     init_attributes();
-    init_context();
-    init_globals();
-    import_jsx_runtime5 = require("react/jsx-runtime");
+    init_context2();
+    init_globals3();
+    import_jsx_runtime8 = require("react/jsx-runtime");
     JmxContent = () => {
-      const { selectedNode } = (0, import_react15.useContext)(MBeanTreeContext);
-      const { pathname, search } = (0, import_react_router_dom2.useLocation)();
+      const { selectedNode } = (0, import_react19.useContext)(MBeanTreeContext);
+      const { pathname, search } = (0, import_react_router2.useLocation)();
       const chatbotContext = useChatbot();
       const { isChatbotOpen, setIsChatbotOpen } = chatbotContext;
-      const drawerRef = (0, import_react15.useRef)(void 0);
+      const drawerRef = (0, import_react19.useRef)(void 0);
       if (!selectedNode) {
-        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.PageSection, { hasBodyWrapper: false, isFilled: true, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.EmptyState, { headingLevel: "h1", icon: import_cubes_icon.CubesIcon, titleText: "Select MBean", variant: "full" }) });
+        return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.PageSection, { hasBodyWrapper: false, isFilled: true, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.EmptyState, { headingLevel: "h1", icon: import_cubes_icon.CubesIcon, titleText: "Select MBean", variant: "full" }) });
       }
       const mBeanApplicable = (node) => Boolean(node.objectName);
       const mBeanCollectionApplicable = (node) => Boolean(node.children?.every((child) => child.objectName));
@@ -3453,42 +1474,42 @@ var init_JmxContent2 = __esm({
       const tableSelector = (node) => {
         const tablePriorityList = [
           { condition: mBeanApplicable, element: Attributes },
-          { condition: mBeanCollectionApplicable, element: import_react14.AttributeTable }
+          { condition: mBeanCollectionApplicable, element: import_react18.AttributeTable }
         ];
-        return tablePriorityList.find((entry) => entry.condition(node))?.element ?? import_react14.JmxContentMBeans;
+        return tablePriorityList.find((entry) => entry.condition(node))?.element ?? import_react18.JmxContentMBeans;
       };
       const allNavItems = [
         { id: "attributes", title: "Attributes", component: tableSelector(selectedNode), isApplicable: () => true },
-        { id: "operations", title: "Operations", component: import_react14.Operations, isApplicable: mBeanApplicable },
-        { id: "chart", title: "Chart", component: import_react14.Chart, isApplicable: hasAnyApplicableMBean }
+        { id: "operations", title: "Operations", component: import_react18.Operations, isApplicable: mBeanApplicable },
+        { id: "chart", title: "Chart", component: import_react18.Chart, isApplicable: hasAnyApplicableMBean }
       ];
       const navItems = allNavItems.filter((nav) => nav.isApplicable(selectedNode));
       const searchWithNid = pluginPathWithNodeId(selectedNode, new URLSearchParams(search)).search;
-      const mbeanNav = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.Nav, { "aria-label": "MBean Nav", variant: "horizontal-subnav", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.NavList, { children: navItems.map((nav) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.NavItem, { isActive: pathname === `${pluginPath}/${nav.id}`, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_router_dom2.NavLink, { to: { pathname: nav.id, search }, children: nav.title }) }, nav.id)) }) });
-      const mbeanRoutes = navItems.map((nav) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_router_dom2.Route, { path: nav.id, element: import_react15.default.createElement(nav.component) }, nav.id));
-      const jmxAiToolbar = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.Toolbar, { id: "jmx-ai-toolbar", style: { float: import_popper_core.right }, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.ToolbarItem, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.Button, { variant: "secondary", size: "sm", onClick: () => setIsChatbotOpen(!isChatbotOpen), children: "Chat" }) }) });
-      const jmxContent = /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_react_core5.PageGroup, { id: "jmx-content", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_react_core5.PageSection, { id: "jmx-content-header", hasBodyWrapper: false, children: [
+      const mbeanNav = /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.Nav, { "aria-label": "MBean Nav", variant: "horizontal-subnav", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.NavList, { children: navItems.map((nav) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.NavItem, { isActive: pathname === `${pluginPath2}/${nav.id}`, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_router2.NavLink, { to: { pathname: nav.id, search }, children: nav.title }) }, nav.id)) }) });
+      const mbeanRoutes = navItems.map((nav) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_router2.Route, { path: nav.id, element: import_react19.default.createElement(nav.component) }, nav.id));
+      const jmxAiToolbar = /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.Toolbar, { id: "jmx-ai-toolbar", style: { float: import_popper_core.right }, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.ToolbarItem, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.Button, { variant: "secondary", size: "sm", onClick: () => setIsChatbotOpen(!isChatbotOpen), children: "Chat" }) }) });
+      const jmxContent = /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_react_core8.PageGroup, { id: "jmx-content", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_react_core8.PageSection, { id: "jmx-content-header", hasBodyWrapper: false, children: [
           jmxAiToolbar,
-          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.Title, { headingLevel: "h1", children: selectedNode.name }),
-          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.Content, { component: "small", children: selectedNode.objectName })
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.Title, { headingLevel: "h1", children: selectedNode.name }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.Content, { component: "small", children: selectedNode.objectName })
         ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.PageSection, { type: "tabs", hasBodyWrapper: false, children: mbeanNav }),
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-          import_react_core5.PageSection,
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.PageSection, { type: "tabs", hasBodyWrapper: false, children: mbeanNav }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          import_react_core8.PageSection,
           {
             id: "jmx-content-main",
             padding: { default: "noPadding" },
             hasOverflowScroll: true,
             "aria-label": "jmx-content-main",
             hasBodyWrapper: false,
-            children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_react_router_dom2.Routes, { children: [
+            children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_react_router2.Routes, { children: [
               mbeanRoutes,
-              /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-                import_react_router_dom2.Route,
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                import_react_router2.Route,
                 {
                   path: "/",
-                  element: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_router_dom2.Navigate, { to: { pathname: navItems[0]?.id ?? "", search: searchWithNid } })
+                  element: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_router2.Navigate, { to: { pathname: navItems[0]?.id ?? "", search: searchWithNid } })
                 },
                 "root"
               )
@@ -3499,8 +1520,8 @@ var init_JmxContent2 = __esm({
       const onDrawerExpand = () => {
         drawerRef.current && drawerRef.current.focus();
       };
-      const panelContent = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.DrawerPanelContent, { isResizable: true, defaultSize: "500px", minSize: "200px", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.DrawerPanelBody, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(DiagnosisChatbot, {}) }) });
-      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ChatbotContext.Provider, { value: chatbotContext, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.Drawer, { isExpanded: isChatbotOpen, isInline: true, onExpand: onDrawerExpand, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.DrawerContent, { panelContent, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_core5.DrawerContentBody, { children: jmxContent }) }) }) });
+      const panelContent = /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.DrawerPanelContent, { isResizable: true, defaultSize: "500px", minSize: "200px", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.DrawerPanelBody, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ChatbotPanel, { title: "AI Diagnosis", displayMode: import_Chatbot3.ChatbotDisplayMode.drawer }) }) });
+      return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ChatbotContext.Provider, { value: chatbotContext, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.Drawer, { isExpanded: isChatbotOpen, isInline: true, onExpand: onDrawerExpand, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.DrawerContent, { panelContent, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core8.DrawerContentBody, { children: jmxContent }) }) }) });
     };
   }
 });
@@ -3512,23 +1533,23 @@ var init_JmxTreeView = __esm({
 });
 
 // src/ai-plugin/jmx-ai/JmxTreeView.tsx
-var import_react16, import_react_core6, import_react17, import_react_router_dom3, import_jsx_runtime6, JmxTreeView;
+var import_react20, import_react_core9, import_react21, import_react_router3, import_jsx_runtime9, JmxTreeView;
 var init_JmxTreeView2 = __esm({
   "src/ai-plugin/jmx-ai/JmxTreeView.tsx"() {
     "use strict";
-    import_react16 = require("@hawtio/react");
-    import_react_core6 = require("@patternfly/react-core");
-    import_react17 = require("react");
-    import_react_router_dom3 = require("react-router-dom");
+    import_react20 = require("@hawtio/react");
+    import_react_core9 = require("@patternfly/react-core");
+    import_react21 = require("react");
+    import_react_router3 = require("react-router");
     init_JmxTreeView();
-    init_context();
-    import_jsx_runtime6 = require("react/jsx-runtime");
+    init_context2();
+    import_jsx_runtime9 = require("react/jsx-runtime");
     JmxTreeView = () => {
-      const { tree, selectedNode, setSelectedNode } = (0, import_react17.useContext)(MBeanTreeContext);
-      const [expanded, setExpanded] = (0, import_react17.useState)(0 /* Default */);
-      const [filteredTree, setFilteredTree] = (0, import_react17.useState)(tree.getTree());
-      const navigate = (0, import_react_router_dom3.useNavigate)();
-      (0, import_react17.useEffect)(() => {
+      const { tree, selectedNode, setSelectedNode } = (0, import_react21.useContext)(MBeanTreeContext);
+      const [expanded, setExpanded] = (0, import_react21.useState)(0 /* Default */);
+      const [filteredTree, setFilteredTree] = (0, import_react21.useState)(tree.getTree());
+      const navigate = (0, import_react_router3.useNavigate)();
+      (0, import_react21.useEffect)(() => {
         setFilteredTree(tree.getTree());
       }, [tree]);
       const onSearch = (event) => {
@@ -3536,7 +1557,7 @@ var init_JmxTreeView2 = __esm({
         setExpanded(0 /* Default */);
         const input = event.target.value;
         if (!input) setFilteredTree(tree.getTree());
-        const treeElements = import_react16.MBeanTree.filter(tree.getTree(), (node) => node.name.toLowerCase().includes(input.toLowerCase()));
+        const treeElements = import_react20.MBeanTree.filter(tree.getTree(), (node) => node.name.toLowerCase().includes(input.toLowerCase()));
         if (treeElements.length === 0) setFilteredTree(tree.getTree());
         else {
           setFilteredTree(treeElements);
@@ -3561,8 +1582,8 @@ var init_JmxTreeView2 = __esm({
             return {};
         }
       };
-      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
-        import_react_core6.TreeView,
+      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        import_react_core9.TreeView,
         {
           id: "jmx-tree-view",
           data: filteredTree,
@@ -3571,7 +1592,7 @@ var init_JmxTreeView2 = __esm({
           activeItems: selectedNode ? [selectedNode] : [],
           ...expandedProp(),
           onSelect,
-          toolbar: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react16.PluginTreeViewToolbar, { onSearch, onSetExpanded: setAllExpanded })
+          toolbar: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react20.PluginTreeViewToolbar, { onSearch, onSetExpanded: setAllExpanded })
         }
       );
     };
@@ -3579,42 +1600,42 @@ var init_JmxTreeView2 = __esm({
 });
 
 // src/ai-plugin/jmx-ai/Jmx.tsx
-var import_react_core7, import_cubes_icon2, import_jsx_runtime7, Jmx;
+var import_react_core10, import_cubes_icon2, import_react_split, import_jsx_runtime10, Jmx;
 var init_Jmx2 = __esm({
   "src/ai-plugin/jmx-ai/Jmx.tsx"() {
     "use strict";
-    import_react_core7 = require("@patternfly/react-core");
+    import_react_core10 = require("@patternfly/react-core");
     import_cubes_icon2 = require("@patternfly/react-icons/dist/esm/icons/cubes-icon");
-    init_react_split_es();
-    init_context();
+    import_react_split = __toESM(require("react-split"));
+    init_context2();
     init_Jmx();
     init_JmxContent2();
     init_JmxTreeView2();
-    import_jsx_runtime7 = require("react/jsx-runtime");
+    import_jsx_runtime10 = require("react/jsx-runtime");
     Jmx = () => {
       const { tree, loaded, selectedNode, setSelectedNode } = useMBeanTree();
       if (!loaded) {
-        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.PageSection, { hasBodyWrapper: false, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.Spinner, { "aria-label": "Loading MBean tree" }) });
+        return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_react_core10.PageSection, { hasBodyWrapper: false, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_react_core10.Spinner, { "aria-label": "Loading MBean tree" }) });
       }
       if (tree.isEmpty()) {
-        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.PageSection, { hasBodyWrapper: false, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core7.EmptyState, { headingLevel: "h1", icon: import_cubes_icon2.CubesIcon, titleText: "No MBeans found", variant: "full" }) });
+        return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_react_core10.PageSection, { hasBodyWrapper: false, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_react_core10.EmptyState, { headingLevel: "h1", icon: import_cubes_icon2.CubesIcon, titleText: "No MBeans found", variant: "full" }) });
       }
-      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(MBeanTreeContext.Provider, { value: { tree, selectedNode, setSelectedNode }, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(react_split_es_default, { className: "jmx-split", sizes: [30, 70], minSize: 200, gutterSize: 5, children: [
-        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(JmxTreeView, {}) }),
-        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(JmxContent, {}) })
+      return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(MBeanTreeContext.Provider, { value: { tree, loaded, selectedNode, setSelectedNode }, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_react_split.default, { className: "jmx-split", sizes: [30, 70], minSize: 200, gutterSize: 5, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(JmxTreeView, {}) }),
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(JmxContent, {}) })
       ] }) });
     };
   }
 });
 
 // src/ai-plugin/jmx-ai/ui.ts
-var ui_exports = {};
-__export(ui_exports, {
+var ui_exports2 = {};
+__export(ui_exports2, {
   Jmx: () => Jmx,
   JmxContent: () => JmxContent,
   JmxTreeView: () => JmxTreeView
 });
-var init_ui = __esm({
+var init_ui2 = __esm({
   "src/ai-plugin/jmx-ai/ui.ts"() {
     "use strict";
     init_Jmx2();
@@ -3629,25 +1650,53 @@ __export(index_exports, {
   plugin: () => plugin
 });
 module.exports = __toCommonJS(index_exports);
-var import_react19 = require("@hawtio/react");
+var import_react23 = require("@hawtio/react");
 var import_main = require("@patternfly/chatbot/dist/css/main.css");
 
+// src/ai-plugin/chat/index.ts
+var import_react9 = require("@hawtio/react");
+init_globals();
+var order = 42;
+var aiChat = () => {
+  log.info("Loading", pluginName);
+  import_react9.hawtio.addDeferredPlugin(pluginName, async () => {
+    return Promise.resolve().then(() => (init_ui(), ui_exports)).then(({ Chat: Chat2 }) => {
+      return {
+        id: pluginName,
+        title: pluginTitle,
+        path: pluginPath,
+        order,
+        component: Chat2,
+        isActive: async () => true
+      };
+    });
+  });
+};
+
 // src/ai-plugin/common/index.ts
-var import_react4 = require("@hawtio/react");
+var import_react11 = require("@hawtio/react");
 
 // src/ai-plugin/common/AiPreferences.tsx
-var import_react_core = require("@patternfly/react-core");
+var import_react_core6 = require("@patternfly/react-core");
 var import_eye_icon = __toESM(require("@patternfly/react-icons/dist/esm/icons/eye-icon"));
 var import_eye_slash_icon = __toESM(require("@patternfly/react-icons/dist/esm/icons/eye-slash-icon"));
-var import_react2 = require("react");
+var import_react_table = require("@patternfly/react-table");
+var import_react10 = require("react");
 init_ai_model();
 init_ai_preferences_service();
-var import_jsx_runtime = require("react/jsx-runtime");
+init_tools();
+var import_jsx_runtime6 = require("react/jsx-runtime");
 var AiPreferences = () => {
-  const [options, setOptions] = (0, import_react2.useState)(aiPreferencesService.loadOptions());
-  const [provider, setProvider] = (0, import_react2.useState)(options.model.provider);
-  const [models, setModels] = (0, import_react2.useState)(MODELS.filter((m) => m.provider === provider));
-  const [passwordHidden, setPasswordHidden] = (0, import_react2.useState)(true);
+  const [options, setOptions] = (0, import_react10.useState)(aiPreferencesService.loadOptions());
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.CardBody, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react_core6.Form, { id: "ai-prefs-form", isHorizontal: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(ModelForm, { options, setOptions }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(PermissionForm, { options, setOptions })
+  ] }) });
+};
+var ModelForm = ({ options, setOptions }) => {
+  const [provider, setProvider] = (0, import_react10.useState)(options.model.provider);
+  const [models, setModels] = (0, import_react10.useState)(MODELS.filter((m) => m.provider === provider));
+  const [passwordHidden, setPasswordHidden] = (0, import_react10.useState)(true);
   const updateProvider = (provider2) => {
     setProvider(provider2);
     setModels(MODELS.filter((m) => m.provider === provider2));
@@ -3663,126 +1712,161 @@ var AiPreferences = () => {
     aiPreferencesService.saveOptions({ token: updated });
     setOptions({ ...options, token: updated });
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.CardBody, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.Form, { isHorizontal: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_core.FormSection, { title: "AI", titleElement: "h2", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.FormGroup, { fieldId: "ai-prefs-form-provider", label: "Provider", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-      import_react_core.FormSelect,
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react_core6.FormSection, { title: "Model", titleElement: "h2", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.FormGroup, { fieldId: "ai-prefs-form-provider", label: "Provider", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      import_react_core6.FormSelect,
       {
         id: "ai-prefs-form-provider-input",
         "aria-label": "Form Select Provider",
         value: provider,
-        onChange: (_, provider2) => updateProvider(provider2),
-        children: PROVIDERS.map((p, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.FormSelectOption, { value: p, label: p }, i))
+        onChange: (_, p) => updateProvider(p),
+        children: PROVIDERS.map((p, i) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.FormSelectOption, { value: p, label: p }, i))
       }
     ) }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.FormGroup, { fieldId: "ai-prefs-form-model", label: "Model", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-      import_react_core.FormSelect,
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.FormGroup, { fieldId: "ai-prefs-form-model", label: "Model", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      import_react_core6.FormSelect,
       {
         id: "ai-prefs-form-model-input",
         "aria-label": "Form Select Model",
         value: options.model.id,
         onChange: (_, id) => updateModel(id),
-        children: models.map((m) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.FormSelectOption, { value: m.id, label: m.name }, m.id))
+        children: models.map((m) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.FormSelectOption, { value: m.id, label: m.name }, m.id))
       }
     ) }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.FormGroup, { fieldId: "ai-prefs-form-token", label: "API Key / Token (optional)", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_core.InputGroup, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.InputGroupItem, { isFill: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-        import_react_core.TextInput,
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.FormGroup, { fieldId: "ai-prefs-form-token", label: "API Key / Token (optional)", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react_core6.InputGroup, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.InputGroupItem, { isFill: true, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        import_react_core6.TextInput,
         {
           id: "ai-prefs-form-token-input",
           "aria-label": "Form Select Token",
           type: passwordHidden ? "password" : "text",
           value: options.token,
-          onChange: (_, token) => updateToken(token)
+          onChange: (_, t) => updateToken(t)
         }
       ) }),
-      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_core.InputGroupItem, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-        import_react_core.Button,
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.InputGroupItem, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        import_react_core6.Button,
         {
           variant: "control",
           onClick: () => setPasswordHidden(!passwordHidden),
           "aria-label": passwordHidden ? "Show password" : "Hide password",
-          children: passwordHidden ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_eye_icon.default, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_eye_slash_icon.default, {})
+          children: passwordHidden ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_eye_icon.default, {}) : /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_eye_slash_icon.default, {})
         }
       ) })
     ] }) })
-  ] }) }) });
+  ] });
+};
+var PermissionForm = ({ options, setOptions }) => {
+  const maxAutoToolSteps = options.maxAutoToolSteps ?? DEFAULT_MAX_AUTO_TOOL_STEPS;
+  const toolPermissions = options.toolPermissions ?? DEFAULT_TOOL_PERMISSIONS;
+  const updateMaxAutoToolSteps = (updated) => {
+    aiPreferencesService.saveOptions({ maxAutoToolSteps: updated });
+    setOptions({ ...options, maxAutoToolSteps: updated });
+  };
+  const updatePermission = (tool, updated) => {
+    const updatedPermissions = { ...toolPermissions, [tool]: updated };
+    aiPreferencesService.saveOptions({ toolPermissions: updatedPermissions });
+    setOptions({ ...options, toolPermissions: updatedPermissions });
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react_core6.FormSection, { title: "Permission control", titleElement: "h2", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.FormGroup, { fieldId: "ai-prefs-form-max-steps", label: "Max auto-approve steps", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      import_react_core6.NumberInput,
+      {
+        id: "ai-prefs-form-max-steps-input",
+        "aria-label": "Form select max auto-approve steps",
+        value: options.maxAutoToolSteps,
+        min: 1,
+        max: 100,
+        onMinus: () => updateMaxAutoToolSteps(Math.max(1, maxAutoToolSteps - 1)),
+        onPlus: () => updateMaxAutoToolSteps(Math.min(100, maxAutoToolSteps + 1)),
+        onChange: (e) => {
+          const value = parseInt(e.target.value);
+          if (!isNaN(value) && value >= 1 && value <= 100) {
+            updateMaxAutoToolSteps(value);
+          }
+        }
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react_core6.FormGroup, { fieldId: "ai-prefs-form-tool-permissions", style: { display: "flex" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_core6.Content, { component: "small", children: "Enable auto-approve to allow a tool to run without asking for confirmation each time." }),
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(
+        import_react_table.Table,
+        {
+          "aria-label": "Tool permissions",
+          variant: "compact",
+          borders: false,
+          isStriped: true,
+          isStickyHeader: true,
+          style: { marginTop: "0.5rem" },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Thead, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react_table.Tr, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Th, { modifier: "fitContent", children: "Tool" }),
+              /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Th, { modifier: "wrap", children: "Description" }),
+              /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Th, { modifier: "fitContent", children: "Auto-approve" })
+            ] }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Tbody, { children: WORKSPACE_TOOLS_META.map(({ name, description }) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react_table.Tr, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Td, { dataLabel: "Tool", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("b", { children: name }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Td, { dataLabel: "Description", children: description }),
+              /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_table.Td, { dataLabel: "Auto-approve", textCenter: true, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+                import_react_core6.Switch,
+                {
+                  id: `ai-prefs-tool-switch-${name}`,
+                  "aria-label": `Auto-approve ${name}`,
+                  isChecked: toolPermissions[name] ?? false,
+                  onChange: (_, checked) => updatePermission(name, checked)
+                }
+              ) })
+            ] }, name)) })
+          ]
+        }
+      )
+    ] })
+  ] });
 };
-
-// src/ai-plugin/common/globals.ts
-var import_react3 = require("@hawtio/react");
-var pluginName2 = "hawtio-ai";
-var pluginTitle2 = "AI";
-var log2 = import_react3.Logger.get(pluginName2);
 
 // src/ai-plugin/common/index.ts
-var order = 40;
+init_globals2();
+var order2 = 40;
 var aiCommon = () => {
-  import_react4.preferencesRegistry.add(pluginName2, pluginTitle2, AiPreferences, order);
+  import_react11.preferencesRegistry.add(pluginName2, pluginTitle2, AiPreferences, order2);
 };
 
 // src/ai-plugin/jmx-ai/index.ts
-var import_react18 = require("@hawtio/react");
-init_globals();
+var import_react22 = require("@hawtio/react");
+init_globals3();
 
 // src/ai-plugin/jmx-ai/help.md
 var help_default = "# JMX AI - Hawtio AI Plugin\n\nThis view is provided by the Hawtio AI plugin.\n\nIt extends the standard [JMX](./jmx) and adds AI features such as MBean diagnostics to it.\n";
 
 // src/ai-plugin/jmx-ai/index.ts
-var order2 = 41;
-var jmxAi = () => {
-  log.info("Loading", pluginName);
-  import_react18.hawtio.addDeferredPlugin(pluginName, async () => {
-    return Promise.resolve().then(() => (init_ui(), ui_exports)).then(({ Jmx: Jmx2 }) => {
+var order3 = 41;
+var aiJmx = () => {
+  log3.info("Loading", pluginName3);
+  import_react22.hawtio.addDeferredPlugin(pluginName3, async () => {
+    return Promise.resolve().then(() => (init_ui2(), ui_exports2)).then(({ Jmx: Jmx2 }) => {
       return {
-        id: pluginName,
-        title: pluginTitle,
-        path: pluginPath,
+        id: pluginName3,
+        title: pluginTitle3,
+        path: pluginPath2,
+        order: order3,
         component: Jmx2,
         knownQueryParams: ["nid"],
-        isActive: async () => import_react18.workspace.hasMBeans()
+        isActive: async () => import_react22.workspace.hasMBeans()
       };
     });
   });
-  import_react18.helpRegistry.add(pluginName, pluginTitle, help_default, order2);
+  import_react22.helpRegistry.add(pluginName3, pluginTitle3, help_default, order3);
 };
 
 // src/ai-plugin/index.ts
 var plugin = () => {
   aiCommon();
-  jmxAi();
+  aiJmx();
+  aiChat();
 };
-import_react19.configManager.addProductInfo("Hawtio AI Plugin", "0.2.1");
+import_react23.configManager.addProductInfo("Hawtio AI Plugin", "0.3.0");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   plugin
 });
-/*! Bundled license information:
-
-react-is/cjs/react-is.production.min.js:
-  (** @license React v16.13.1
-   * react-is.production.min.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-
-react-is/cjs/react-is.development.js:
-  (** @license React v16.13.1
-   * react-is.development.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-
-object-assign/index.js:
-  (*
-  object-assign
-  (c) Sindre Sorhus
-  @license MIT
-  *)
-*/
 //# sourceMappingURL=index.js.map