@rodrigocoliveira/agno-react 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,109 +1,123 @@
-"use strict";
 var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AgnoProvider: () => AgnoProvider,
-  ComponentRegistry: () => ComponentRegistry,
-  GenerativeUIRenderer: () => GenerativeUIRenderer,
-  ToolHandlerProvider: () => ToolHandlerProvider,
-  createAreaChart: () => createAreaChart,
-  createArtifact: () => createArtifact,
-  createBarChart: () => createBarChart,
-  createCard: () => createCard,
-  createCardGrid: () => createCardGrid,
-  createColumn: () => createColumn,
-  createLineChart: () => createLineChart,
-  createMarkdown: () => createMarkdown,
-  createPieChart: () => createPieChart,
-  createSmartChart: () => createSmartChart,
-  createTable: () => createTable,
-  createToolResult: () => createToolResult,
-  getChartComponent: () => getChartComponent,
-  getComponentRegistry: () => getComponentRegistry,
-  getCustomRender: () => getCustomRender,
-  registerChartComponent: () => registerChartComponent,
-  resultWithBarChart: () => resultWithBarChart,
-  resultWithCardGrid: () => resultWithCardGrid,
-  resultWithSmartChart: () => resultWithSmartChart,
-  resultWithTable: () => resultWithTable,
-  useAgnoActions: () => useAgnoActions,
-  useAgnoChat: () => useAgnoChat,
-  useAgnoClient: () => useAgnoClient,
-  useAgnoCustomEvents: () => useAgnoCustomEvents,
-  useAgnoEvals: () => useAgnoEvals,
-  useAgnoKnowledge: () => useAgnoKnowledge,
-  useAgnoMemory: () => useAgnoMemory,
-  useAgnoMetrics: () => useAgnoMetrics,
-  useAgnoSession: () => useAgnoSession,
-  useAgnoToolExecution: () => useAgnoToolExecution,
+var exports_src = {};
+__export(exports_src, {
+  useToolHandlers: () => useToolHandlers,
   useAgnoTraces: () => useAgnoTraces,
-  useToolHandlers: () => useToolHandlers
+  useAgnoToolExecution: () => useAgnoToolExecution,
+  useAgnoSession: () => useAgnoSession,
+  useAgnoMetrics: () => useAgnoMetrics,
+  useAgnoMemory: () => useAgnoMemory,
+  useAgnoKnowledge: () => useAgnoKnowledge,
+  useAgnoEvals: () => useAgnoEvals,
+  useAgnoCustomEvents: () => useAgnoCustomEvents,
+  useAgnoClient: () => useAgnoClient,
+  useAgnoChat: () => useAgnoChat,
+  useAgnoActions: () => useAgnoActions,
+  resultWithTable: () => resultWithTable,
+  resultWithSmartChart: () => resultWithSmartChart,
+  resultWithCardGrid: () => resultWithCardGrid,
+  resultWithBarChart: () => resultWithBarChart,
+  registerChartComponent: () => registerChartComponent,
+  getCustomRender: () => getCustomRender,
+  getComponentRegistry: () => getComponentRegistry,
+  getChartComponent: () => getChartComponent,
+  createToolResult: () => createToolResult,
+  createTable: () => createTable,
+  createSmartChart: () => createSmartChart,
+  createPieChart: () => createPieChart,
+  createMarkdown: () => createMarkdown,
+  createLineChart: () => createLineChart,
+  createColumn: () => createColumn,
+  createCardGrid: () => createCardGrid,
+  createCard: () => createCard,
+  createBarChart: () => createBarChart,
+  createArtifact: () => createArtifact,
+  createAreaChart: () => createAreaChart,
+  ToolHandlerProvider: () => ToolHandlerProvider,
+  GenerativeUIRenderer: () => GenerativeUIRenderer,
+  ComponentRegistry: () => ComponentRegistry,
+  AgnoProvider: () => AgnoProvider
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(exports_src);
 
 // src/context/AgnoContext.tsx
 var import_react = require("react");
 var import_agno_client = require("@rodrigocoliveira/agno-client");
-var import_jsx_runtime = require("react/jsx-runtime");
-var AgnoContext = (0, import_react.createContext)(null);
+var jsx_dev_runtime = require("react/jsx-dev-runtime");
+var AgnoContext = import_react.createContext(null);
 function AgnoProvider({ config, children }) {
-  const client = (0, import_react.useMemo)(() => new import_agno_client.AgnoClient(config), []);
-  (0, import_react.useEffect)(() => {
+  const client = import_react.useMemo(() => new import_agno_client.AgnoClient(config), []);
+  import_react.useEffect(() => {
     client.updateConfig(config);
   }, [client, config]);
-  (0, import_react.useEffect)(() => {
+  import_react.useEffect(() => {
     return () => {
       client.removeAllListeners();
     };
   }, [client]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AgnoContext.Provider, { value: client, children });
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(AgnoContext.Provider, {
+    value: client,
+    children
+  }, undefined, false, undefined, this);
 }
 function useAgnoClient() {
-  const client = (0, import_react.useContext)(AgnoContext);
+  const client = import_react.useContext(AgnoContext);
   if (!client) {
     throw new Error("useAgnoClient must be used within an AgnoProvider");
   }
   return client;
 }
-
 // src/context/ToolHandlerContext.tsx
 var import_react2 = require("react");
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var ToolHandlerContext = (0, import_react2.createContext)(null);
+var jsx_dev_runtime2 = require("react/jsx-dev-runtime");
+var ToolHandlerContext = import_react2.createContext(null);
 function ToolHandlerProvider({ handlers: initialHandlers = {}, children }) {
-  const [handlers, setHandlers] = (0, import_react2.useState)(initialHandlers);
-  const registerHandler = (0, import_react2.useCallback)((name, handler) => {
+  const [handlers, setHandlers] = import_react2.useState(initialHandlers);
+  const registerHandler = import_react2.useCallback((name, handler) => {
     setHandlers((prev) => ({ ...prev, [name]: handler }));
   }, []);
-  const unregisterHandler = (0, import_react2.useCallback)((name) => {
+  const unregisterHandler = import_react2.useCallback((name) => {
     setHandlers((prev) => {
       const { [name]: _, ...rest } = prev;
       return rest;
@@ -114,74 +128,52 @@ function ToolHandlerProvider({ handlers: initialHandlers = {}, children }) {
     registerHandler,
     unregisterHandler
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ToolHandlerContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ToolHandlerContext.Provider, {
+    value,
+    children
+  }, undefined, false, undefined, this);
 }
 function useToolHandlers() {
-  return (0, import_react2.useContext)(ToolHandlerContext);
+  return import_react2.useContext(ToolHandlerContext);
 }
-
 // src/components/GenerativeUIRenderer.tsx
 var import_react4 = __toESM(require("react"));
 
 // src/utils/component-registry.ts
-var ComponentRegistry = class _ComponentRegistry {
-  constructor() {
-    this.components = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Get the singleton instance
-   */
+class ComponentRegistry {
+  static instance;
+  components = new Map;
+  constructor() {}
   static getInstance() {
-    if (!_ComponentRegistry.instance) {
-      _ComponentRegistry.instance = new _ComponentRegistry();
+    if (!ComponentRegistry.instance) {
+      ComponentRegistry.instance = new ComponentRegistry;
     }
-    return _ComponentRegistry.instance;
+    return ComponentRegistry.instance;
   }
-  /**
-   * Register a component renderer
-   */
   register(type, renderer) {
     this.components.set(type, renderer);
   }
-  /**
-   * Register multiple components at once
-   */
   registerBatch(components) {
     Object.entries(components).forEach(([type, renderer]) => {
       this.register(type, renderer);
     });
   }
-  /**
-   * Get a registered component renderer
-   */
   get(type) {
     return this.components.get(type);
   }
-  /**
-   * Check if a component is registered
-   */
   has(type) {
     return this.components.has(type);
   }
-  /**
-   * Unregister a component
-   */
   unregister(type) {
     this.components.delete(type);
   }
-  /**
-   * Get all registered component types
-   */
   getRegisteredTypes() {
     return Array.from(this.components.keys());
   }
-  /**
-   * Clear all registered components
-   */
   clear() {
     this.components.clear();
   }
-};
+}
 function getComponentRegistry() {
   return ComponentRegistry.getInstance();
 }
@@ -194,7 +186,7 @@ function getChartComponent(name) {
 
 // src/hooks/useAgnoToolExecution.ts
 var import_react3 = require("react");
-var customRenderRegistry = /* @__PURE__ */ new Map();
+var customRenderRegistry = new Map;
 function registerCustomRender(renderFn) {
   const key = `custom-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
   customRenderRegistry.set(key, renderFn);
@@ -204,7 +196,7 @@ function getCustomRender(key) {
   return customRenderRegistry.get(key);
 }
 function isToolHandlerResult(value) {
-  return value && typeof value === "object" && ("data" in value || "ui" in value);
+  return value && typeof value === "object" && (("data" in value) || ("ui" in value));
 }
 function isUIComponentSpec(value) {
   return value && typeof value === "object" && "type" in value;
@@ -212,15 +204,14 @@ function isUIComponentSpec(value) {
 function processToolResult(result, _tool) {
   if (isToolHandlerResult(result)) {
     const { data, ui } = result;
-    let uiComponent = void 0;
+    let uiComponent = undefined;
     if (ui) {
       if (ui.type === "custom" && typeof ui.render === "function") {
         const renderKey = registerCustomRender(ui.render);
         uiComponent = {
           ...ui,
           renderKey,
-          render: void 0
-          // Don't store the function itself
+          render: undefined
         };
       } else {
         uiComponent = ui;
@@ -238,7 +229,7 @@ function processToolResult(result, _tool) {
       uiComponent = {
         ...result,
         renderKey,
-        render: void 0
+        render: undefined
       };
     } else {
       uiComponent = result;
@@ -250,42 +241,40 @@ function processToolResult(result, _tool) {
   }
   return {
     resultData: typeof result === "string" ? result : JSON.stringify(result),
-    uiComponent: void 0
+    uiComponent: undefined
   };
 }
 function useAgnoToolExecution(handlers = {}, autoExecute = true) {
   const client = useAgnoClient();
   const toolHandlerContext = useToolHandlers();
   const isTeamMode = client.getConfig().mode === "team";
-  (0, import_react3.useEffect)(() => {
+  import_react3.useEffect(() => {
     if (isTeamMode) {
-      console.warn(
-        "[useAgnoToolExecution] HITL (Human-in-the-Loop) frontend tool execution is not supported for teams. Only agents support the continue endpoint. This hook will not function in team mode."
-      );
+      console.warn("[useAgnoToolExecution] HITL (Human-in-the-Loop) frontend tool execution is not supported for teams. " + "Only agents support the continue endpoint. This hook will not function in team mode.");
     }
   }, [isTeamMode]);
-  const mergedHandlers = (0, import_react3.useMemo)(() => {
+  const mergedHandlers = import_react3.useMemo(() => {
     const globalHandlers = toolHandlerContext?.handlers || {};
     return { ...globalHandlers, ...handlers };
   }, [toolHandlerContext?.handlers, handlers]);
-  const [pendingTools, setPendingTools] = (0, import_react3.useState)([]);
-  const [isPaused, setIsPaused] = (0, import_react3.useState)(false);
-  const [isExecuting, setIsExecuting] = (0, import_react3.useState)(false);
-  const [executionError, setExecutionError] = (0, import_react3.useState)();
-  (0, import_react3.useEffect)(() => {
+  const [pendingTools, setPendingTools] = import_react3.useState([]);
+  const [isPaused, setIsPaused] = import_react3.useState(false);
+  const [isExecuting, setIsExecuting] = import_react3.useState(false);
+  const [executionError, setExecutionError] = import_react3.useState();
+  import_react3.useEffect(() => {
     if (isTeamMode) {
       return;
     }
     const handleRunPaused = (event) => {
       setIsPaused(true);
       setPendingTools(event.tools);
-      setExecutionError(void 0);
+      setExecutionError(undefined);
     };
     const handleRunContinued = () => {
       setIsPaused(false);
       setPendingTools([]);
       setIsExecuting(false);
-      setExecutionError(void 0);
+      setExecutionError(undefined);
     };
     client.on("run:paused", handleRunPaused);
     client.on("run:continued", handleRunContinued);
@@ -294,43 +283,41 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
       client.off("run:continued", handleRunContinued);
     };
   }, [client, isTeamMode]);
-  const executeAndContinue = (0, import_react3.useCallback)(async () => {
+  const executeAndContinue = import_react3.useCallback(async () => {
     if (!isPaused || pendingTools.length === 0) {
       console.warn("[useAgnoToolExecution] Cannot execute: no pending tools");
       return;
     }
     setIsExecuting(true);
-    setExecutionError(void 0);
+    setExecutionError(undefined);
     try {
-      const updatedTools = await Promise.all(
-        pendingTools.map(async (tool) => {
-          const handler = mergedHandlers[tool.tool_name];
-          if (!handler) {
-            return {
-              ...tool,
-              result: JSON.stringify({
-                error: `No handler registered for ${tool.tool_name}`
-              })
-            };
-          }
-          try {
-            const result = await handler(tool.tool_args);
-            const { resultData, uiComponent } = processToolResult(result, tool);
-            return {
-              ...tool,
-              result: resultData,
-              ui_component: uiComponent
-            };
-          } catch (error) {
-            return {
-              ...tool,
-              result: JSON.stringify({
-                error: error instanceof Error ? error.message : String(error)
-              })
-            };
-          }
-        })
-      );
+      const updatedTools = await Promise.all(pendingTools.map(async (tool) => {
+        const handler = mergedHandlers[tool.tool_name];
+        if (!handler) {
+          return {
+            ...tool,
+            result: JSON.stringify({
+              error: `No handler registered for ${tool.tool_name}`
+            })
+          };
+        }
+        try {
+          const result = await handler(tool.tool_args);
+          const { resultData, uiComponent } = processToolResult(result, tool);
+          return {
+            ...tool,
+            result: resultData,
+            ui_component: uiComponent
+          };
+        } catch (error) {
+          return {
+            ...tool,
+            result: JSON.stringify({
+              error: error instanceof Error ? error.message : String(error)
+            })
+          };
+        }
+      }));
       const toolsWithUI = updatedTools.filter((t) => t.ui_component);
       if (toolsWithUI.length > 0) {
         client.emit("ui:render", {
@@ -347,15 +334,18 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
       throw error;
     }
   }, [client, mergedHandlers, isPaused, pendingTools]);
-  (0, import_react3.useEffect)(() => {
+  import_react3.useEffect(() => {
     const handleSessionLoaded = async (_sessionId) => {
       const messages = client.getMessages();
       for (const message of messages) {
-        if (!message.tool_calls) continue;
+        if (!message.tool_calls)
+          continue;
         for (const tool of message.tool_calls) {
-          if (tool.ui_component) continue;
+          if (tool.ui_component)
+            continue;
           const handler = mergedHandlers[tool.tool_name];
-          if (!handler) continue;
+          if (!handler)
+            continue;
           try {
             const result = await handler(tool.tool_args);
             const { uiComponent } = processToolResult(result, tool);
@@ -373,74 +363,61 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
       client.off("session:loaded", handleSessionLoaded);
     };
   }, [client, mergedHandlers]);
-  const executeTools = (0, import_react3.useCallback)(
-    async (tools) => {
-      return Promise.all(
-        tools.map(async (tool) => {
-          const handler = mergedHandlers[tool.tool_name];
-          if (!handler) return tool;
-          try {
-            const result = await handler(tool.tool_args);
-            const { resultData, uiComponent } = processToolResult(result, tool);
-            return {
-              ...tool,
-              result: resultData,
-              ui_component: uiComponent
-            };
-          } catch (error) {
-            return {
-              ...tool,
-              result: JSON.stringify({
-                error: error instanceof Error ? error.message : String(error)
-              })
-            };
-          }
-        })
-      );
-    },
-    [mergedHandlers]
-  );
-  const continueWithResults = (0, import_react3.useCallback)(
-    async (tools, options) => {
-      if (!isPaused) {
-        throw new Error("No paused run to continue");
-      }
-      setIsExecuting(true);
+  const executeTools = import_react3.useCallback(async (tools) => {
+    return Promise.all(tools.map(async (tool) => {
+      const handler = mergedHandlers[tool.tool_name];
+      if (!handler)
+        return tool;
       try {
-        await client.continueRun(tools, options);
+        const result = await handler(tool.tool_args);
+        const { resultData, uiComponent } = processToolResult(result, tool);
+        return {
+          ...tool,
+          result: resultData,
+          ui_component: uiComponent
+        };
       } catch (error) {
-        setIsExecuting(false);
-        throw error;
+        return {
+          ...tool,
+          result: JSON.stringify({
+            error: error instanceof Error ? error.message : String(error)
+          })
+        };
       }
-    },
-    [client, isPaused]
-  );
-  (0, import_react3.useEffect)(() => {
+    }));
+  }, [mergedHandlers]);
+  const continueWithResults = import_react3.useCallback(async (tools, options) => {
+    if (!isPaused) {
+      throw new Error("No paused run to continue");
+    }
+    setIsExecuting(true);
+    try {
+      await client.continueRun(tools, options);
+    } catch (error) {
+      setIsExecuting(false);
+      throw error;
+    }
+  }, [client, isPaused]);
+  import_react3.useEffect(() => {
     if (autoExecute && isPaused && !isExecuting && pendingTools.length > 0) {
       executeAndContinue();
     }
   }, [autoExecute, isPaused, isExecuting, pendingTools.length, executeAndContinue]);
   return {
-    /** Whether the run is currently paused awaiting tool execution */
     isPaused,
-    /** Whether tools are currently being executed */
     isExecuting,
-    /** Tools awaiting execution */
     pendingTools,
-    /** Execute all pending tools and continue the run */
     executeAndContinue,
-    /** Execute specific tools and return results without continuing */
     executeTools,
-    /** Continue the run with manually provided tool results */
     continueWithResults,
-    /** Error from tool execution, if any */
     executionError
   };
 }
 
 // src/components/GenerativeUIRenderer.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var UIErrorBoundary = class extends import_react4.default.Component {
+var jsx_dev_runtime3 = require("react/jsx-dev-runtime");
+
+class UIErrorBoundary extends import_react4.default.Component {
   constructor(props) {
     super(props);
     this.state = { hasError: false };
@@ -454,14 +431,23 @@ var UIErrorBoundary = class extends import_react4.default.Component {
   }
   render() {
     if (this.state.hasError) {
-      return this.props.fallback || /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "p-4 border border-red-300 rounded-md bg-red-50 text-red-800", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "font-semibold", children: "Failed to render UI component" }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm mt-1", children: this.state.error?.message || "Unknown error" })
-      ] });
+      return this.props.fallback || /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+        className: "p-4 border border-red-300 rounded-md bg-red-50 text-red-800",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+            className: "font-semibold",
+            children: "Failed to render UI component"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+            className: "text-sm mt-1",
+            children: this.state.error?.message || "Unknown error"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
     }
     return this.props.children;
   }
-};
+}
 function GenerativeUIRenderer({
   spec,
   className,
@@ -473,78 +459,184 @@ function GenerativeUIRenderer({
     if (customSpec.renderKey) {
       const renderFn = getCustomRender(customSpec.renderKey);
       if (renderFn) {
-        return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(UIErrorBoundary, { onError, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className, children: renderFn(customSpec.props || {}) }) });
+        return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(UIErrorBoundary, {
+          onError,
+          children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+            className,
+            children: renderFn(customSpec.props || {})
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this);
       }
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: `p-4 border border-yellow-300 rounded-md bg-yellow-50 text-yellow-800 ${className || ""}`, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "font-semibold", children: "Custom component not available" }),
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm mt-1", children: "The custom render function for this component is not available." })
-    ] });
+    return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+      className: `p-4 border border-yellow-300 rounded-md bg-yellow-50 text-yellow-800 ${className || ""}`,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+          className: "font-semibold",
+          children: "Custom component not available"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+          className: "text-sm mt-1",
+          children: "The custom render function for this component is not available."
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
   }
   if (spec.type === "chart") {
     const chartSpec = spec;
     const chartType = `chart:${chartSpec.component}`;
     if (registry.has(chartType)) {
       const ChartRenderer = registry.get(chartType);
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(UIErrorBoundary, { onError, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className, children: [
-        chartSpec.title && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h3", { className: "font-semibold mb-2", children: chartSpec.title }),
-        chartSpec.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm text-gray-600 mb-4", children: chartSpec.description }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ChartRenderer, { ...chartSpec.props })
-      ] }) });
-    }
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: `p-4 border border-gray-300 rounded-md ${className || ""}`, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "font-semibold mb-2", children: chartSpec.title || "Chart Data" }),
-      chartSpec.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm text-gray-600 mb-2", children: chartSpec.description }),
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("pre", { className: "text-xs bg-gray-100 p-2 rounded overflow-auto", children: JSON.stringify(chartSpec.props.data, null, 2) })
-    ] });
+      return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+          className,
+          children: [
+            chartSpec.title && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("h3", {
+              className: "font-semibold mb-2",
+              children: chartSpec.title
+            }, undefined, false, undefined, this),
+            chartSpec.description && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+              className: "text-sm text-gray-600 mb-4",
+              children: chartSpec.description
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ChartRenderer, {
+              ...chartSpec.props
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this);
+    }
+    return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+      className: `p-4 border border-gray-300 rounded-md ${className || ""}`,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+          className: "font-semibold mb-2",
+          children: chartSpec.title || "Chart Data"
+        }, undefined, false, undefined, this),
+        chartSpec.description && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+          className: "text-sm text-gray-600 mb-2",
+          children: chartSpec.description
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("pre", {
+          className: "text-xs bg-gray-100 p-2 rounded overflow-auto",
+          children: JSON.stringify(chartSpec.props.data, null, 2)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
   }
   if (spec.type === "card-grid") {
     const cardGridSpec = spec;
     if (registry.has("card-grid")) {
       const CardGridRenderer = registry.get("card-grid");
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(UIErrorBoundary, { onError, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className, children: [
-        cardGridSpec.title && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h3", { className: "font-semibold mb-2", children: cardGridSpec.title }),
-        cardGridSpec.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm text-gray-600 mb-4", children: cardGridSpec.description }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(CardGridRenderer, { ...cardGridSpec.props })
-      ] }) });
+      return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+          className,
+          children: [
+            cardGridSpec.title && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("h3", {
+              className: "font-semibold mb-2",
+              children: cardGridSpec.title
+            }, undefined, false, undefined, this),
+            cardGridSpec.description && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+              className: "text-sm text-gray-600 mb-4",
+              children: cardGridSpec.description
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(CardGridRenderer, {
+              ...cardGridSpec.props
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this);
     }
   }
   if (spec.type === "table") {
     const tableSpec = spec;
     if (registry.has("table")) {
       const TableRenderer = registry.get("table");
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(UIErrorBoundary, { onError, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className, children: [
-        tableSpec.title && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h3", { className: "font-semibold mb-2", children: tableSpec.title }),
-        tableSpec.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm text-gray-600 mb-4", children: tableSpec.description }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TableRenderer, { ...tableSpec.props })
-      ] }) });
+      return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+          className,
+          children: [
+            tableSpec.title && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("h3", {
+              className: "font-semibold mb-2",
+              children: tableSpec.title
+            }, undefined, false, undefined, this),
+            tableSpec.description && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+              className: "text-sm text-gray-600 mb-4",
+              children: tableSpec.description
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(TableRenderer, {
+              ...tableSpec.props
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this);
     }
   }
   if (spec.type === "markdown") {
     const markdownSpec = spec;
     if (registry.has("markdown")) {
       const MarkdownRenderer = registry.get("markdown");
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(UIErrorBoundary, { onError, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MarkdownRenderer, { ...markdownSpec.props }) }) });
+      return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+          className,
+          children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(MarkdownRenderer, {
+            ...markdownSpec.props
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this);
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className, children: markdownSpec.props.content });
+    return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+      className,
+      children: markdownSpec.props.content
+    }, undefined, false, undefined, this);
   }
   if (spec.type === "artifact") {
     const artifactSpec = spec;
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(UIErrorBoundary, { onError, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: `p-4 border rounded-md ${className || ""}`, children: [
-      artifactSpec.title && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h3", { className: "font-semibold mb-4", children: artifactSpec.title }),
-      artifactSpec.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm text-gray-600 mb-4", children: artifactSpec.description }),
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "space-y-4", children: artifactSpec.props.content?.map((childSpec, index) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(GenerativeUIRenderer, { spec: childSpec, onError }, index)) })
-    ] }) });
+    return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(UIErrorBoundary, {
+      onError,
+      children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+        className: `p-4 border rounded-md ${className || ""}`,
+        children: [
+          artifactSpec.title && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("h3", {
+            className: "font-semibold mb-4",
+            children: artifactSpec.title
+          }, undefined, false, undefined, this),
+          artifactSpec.description && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+            className: "text-sm text-gray-600 mb-4",
+            children: artifactSpec.description
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+            className: "space-y-4",
+            children: artifactSpec.props.content?.map((childSpec, index) => /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(GenerativeUIRenderer, {
+              spec: childSpec,
+              onError
+            }, index, false, undefined, this))
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: `p-4 border border-gray-300 rounded-md ${className || ""}`, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "font-semibold", children: "Unsupported UI component" }),
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("p", { className: "text-sm text-gray-600 mt-1", children: [
-      "Component type: ",
-      spec.type
-    ] })
-  ] });
+  return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("div", {
+    className: `p-4 border border-gray-300 rounded-md ${className || ""}`,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+        className: "font-semibold",
+        children: "Unsupported UI component"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("p", {
+        className: "text-sm text-gray-600 mt-1",
+        children: [
+          "Component type: ",
+          spec.type
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
 }
-
 // src/utils/ui-helpers.ts
 function createBarChart(data, xKey, bars, options) {
   return {
@@ -710,34 +802,17 @@ function createSmartChart(data, options) {
   }
   const firstItem = data[0];
   const keys = Object.keys(firstItem);
-  const xKey = options?.xKey || keys.find(
-    (k) => ["name", "label", "category", "date", "time", "month", "year"].includes(k.toLowerCase())
-  ) || keys[0];
+  const xKey = options?.xKey || keys.find((k) => ["name", "label", "category", "date", "time", "month", "year"].includes(k.toLowerCase())) || keys[0];
   const numericKeys = keys.filter((k) => k !== xKey && typeof firstItem[k] === "number");
   const yKeys = options?.yKeys || numericKeys;
   if (options?.preferredType) {
     switch (options.preferredType) {
       case "bar":
-        return createBarChart(
-          data,
-          xKey,
-          yKeys.map((key) => ({ key })),
-          options
-        );
+        return createBarChart(data, xKey, yKeys.map((key) => ({ key })), options);
       case "line":
-        return createLineChart(
-          data,
-          xKey,
-          yKeys.map((key) => ({ key })),
-          options
-        );
+        return createLineChart(data, xKey, yKeys.map((key) => ({ key })), options);
       case "area":
-        return createAreaChart(
-          data,
-          xKey,
-          yKeys.map((key) => ({ key })),
-          options
-        );
+        return createAreaChart(data, xKey, yKeys.map((key) => ({ key })), options);
       case "pie":
         return createPieChart(data, yKeys[0], xKey, options);
     }
@@ -746,19 +821,9 @@ function createSmartChart(data, options) {
     return createPieChart(data, yKeys[0], xKey, options);
   }
   if (xKey.toLowerCase().includes("date") || xKey.toLowerCase().includes("time") || xKey.toLowerCase().includes("month") || xKey.toLowerCase().includes("year")) {
-    return createLineChart(
-      data,
-      xKey,
-      yKeys.map((key) => ({ key })),
-      options
-    );
+    return createLineChart(data, xKey, yKeys.map((key) => ({ key })), options);
   }
-  return createBarChart(
-    data,
-    xKey,
-    yKeys.map((key) => ({ key })),
-    options
-  );
+  return createBarChart(data, xKey, yKeys.map((key) => ({ key })), options);
 }
 function createToolResult(data, ui) {
   return { data, ui };
@@ -775,15 +840,14 @@ function resultWithCardGrid(cards, options) {
 function resultWithTable(data, columns, options) {
   return createToolResult(data, createTable(data, columns, options));
 }
-
 // src/hooks/useAgnoChat.ts
 var import_react5 = require("react");
 function useAgnoChat() {
   const client = useAgnoClient();
-  const [messages, setMessages] = (0, import_react5.useState)(client.getMessages());
-  const [state, setState] = (0, import_react5.useState)(client.getState());
-  const [error, setError] = (0, import_react5.useState)();
-  (0, import_react5.useEffect)(() => {
+  const [messages, setMessages] = import_react5.useState(client.getMessages());
+  const [state, setState] = import_react5.useState(client.getState());
+  const [error, setError] = import_react5.useState();
+  import_react5.useEffect(() => {
     const handleMessageUpdate = (updatedMessages) => {
       setMessages(updatedMessages);
     };
@@ -807,8 +871,7 @@ function useAgnoChat() {
         }
       }
     };
-    const handleRunCancelled = () => {
-    };
+    const handleRunCancelled = () => {};
     client.on("message:update", handleMessageUpdate);
     client.on("message:complete", handleMessageComplete);
     client.on("message:refreshed", handleMessageRefreshed);
@@ -828,25 +891,22 @@ function useAgnoChat() {
       client.off("run:cancelled", handleRunCancelled);
     };
   }, [client]);
-  const sendMessage = (0, import_react5.useCallback)(
-    async (message, options) => {
-      setError(void 0);
-      try {
-        await client.sendMessage(message, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      }
-    },
-    [client]
-  );
-  const clearMessages = (0, import_react5.useCallback)(() => {
+  const sendMessage = import_react5.useCallback(async (message, options) => {
+    setError(undefined);
+    try {
+      await client.sendMessage(message, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    }
+  }, [client]);
+  const clearMessages = import_react5.useCallback(() => {
     client.clearMessages();
     setMessages([]);
-    setError(void 0);
+    setError(undefined);
   }, [client]);
-  const cancelRun = (0, import_react5.useCallback)(async () => {
+  const cancelRun = import_react5.useCallback(async () => {
     try {
       await client.cancelRun();
     } catch (err) {
@@ -869,18 +929,15 @@ function useAgnoChat() {
     state
   };
 }
-
 // src/hooks/useAgnoSession.ts
 var import_react6 = require("react");
 function useAgnoSession() {
   const client = useAgnoClient();
-  const [sessions, setSessions] = (0, import_react6.useState)([]);
-  const [currentSessionId, setCurrentSessionId] = (0, import_react6.useState)(
-    client.getConfig().sessionId
-  );
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
-  const [error, setError] = (0, import_react6.useState)();
-  (0, import_react6.useEffect)(() => {
+  const [sessions, setSessions] = import_react6.useState([]);
+  const [currentSessionId, setCurrentSessionId] = import_react6.useState(client.getConfig().sessionId);
+  const [isLoading, setIsLoading] = import_react6.useState(false);
+  const [error, setError] = import_react6.useState();
+  import_react6.useEffect(() => {
     const handleSessionLoaded = (sessionId) => {
       setCurrentSessionId(sessionId);
     };
@@ -904,27 +961,24 @@ function useAgnoSession() {
       client.off("state:change", handleStateChange);
     };
   }, [client]);
-  const loadSession = (0, import_react6.useCallback)(
-    async (sessionId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const messages = await client.loadSession(sessionId, options);
-        setCurrentSessionId(sessionId);
-        return messages;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const fetchSessions = (0, import_react6.useCallback)(async (options) => {
+  const loadSession = import_react6.useCallback(async (sessionId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const messages = await client.loadSession(sessionId, options);
+      setCurrentSessionId(sessionId);
+      return messages;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const fetchSessions = import_react6.useCallback(async (options) => {
     setIsLoading(true);
-    setError(void 0);
+    setError(undefined);
     try {
       const fetchedSessions = await client.fetchSessions(options);
       setSessions(fetchedSessions);
@@ -937,119 +991,98 @@ function useAgnoSession() {
       setIsLoading(false);
     }
   }, [client]);
-  const getSessionById = (0, import_react6.useCallback)(
-    async (sessionId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getSessionById(sessionId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getRunById = (0, import_react6.useCallback)(
-    async (sessionId, runId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getRunById(sessionId, runId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const createSession = (0, import_react6.useCallback)(
-    async (request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const session = await client.createSession(request, options);
-        return session;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const updateSession = (0, import_react6.useCallback)(
-    async (sessionId, request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.updateSession(sessionId, request, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const renameSession = (0, import_react6.useCallback)(
-    async (sessionId, newName, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.renameSession(sessionId, newName, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const deleteSession = (0, import_react6.useCallback)(
-    async (sessionId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        await client.deleteSession(sessionId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const deleteMultipleSessions = (0, import_react6.useCallback)(
-    async (sessionIds, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        await client.deleteMultipleSessions(sessionIds, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
+  const getSessionById = import_react6.useCallback(async (sessionId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getSessionById(sessionId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getRunById = import_react6.useCallback(async (sessionId, runId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getRunById(sessionId, runId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const createSession = import_react6.useCallback(async (request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const session = await client.createSession(request, options);
+      return session;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const updateSession = import_react6.useCallback(async (sessionId, request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.updateSession(sessionId, request, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const renameSession = import_react6.useCallback(async (sessionId, newName, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.renameSession(sessionId, newName, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const deleteSession = import_react6.useCallback(async (sessionId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      await client.deleteSession(sessionId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const deleteMultipleSessions = import_react6.useCallback(async (sessionIds, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      await client.deleteMultipleSessions(sessionIds, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
   return {
     sessions,
     currentSessionId,
@@ -1066,16 +1099,15 @@ function useAgnoSession() {
     error
   };
 }
-
 // src/hooks/useAgnoActions.ts
 var import_react7 = require("react");
 function useAgnoActions() {
   const client = useAgnoClient();
-  const [isInitializing, setIsInitializing] = (0, import_react7.useState)(false);
-  const [error, setError] = (0, import_react7.useState)();
-  const initialize = (0, import_react7.useCallback)(async (options) => {
+  const [isInitializing, setIsInitializing] = import_react7.useState(false);
+  const [error, setError] = import_react7.useState();
+  const initialize = import_react7.useCallback(async (options) => {
     setIsInitializing(true);
-    setError(void 0);
+    setError(undefined);
     try {
       const result = await client.initialize(options);
       return result;
@@ -1087,8 +1119,8 @@ function useAgnoActions() {
       setIsInitializing(false);
     }
   }, [client]);
-  const checkStatus = (0, import_react7.useCallback)(async (options) => {
-    setError(void 0);
+  const checkStatus = import_react7.useCallback(async (options) => {
+    setError(undefined);
     try {
       return await client.checkStatus(options);
     } catch (err) {
@@ -1097,8 +1129,8 @@ function useAgnoActions() {
       return false;
     }
   }, [client]);
-  const fetchAgents = (0, import_react7.useCallback)(async (options) => {
-    setError(void 0);
+  const fetchAgents = import_react7.useCallback(async (options) => {
+    setError(undefined);
     try {
       return await client.fetchAgents(options);
     } catch (err) {
@@ -1107,8 +1139,8 @@ function useAgnoActions() {
       throw err;
     }
   }, [client]);
-  const fetchTeams = (0, import_react7.useCallback)(async (options) => {
-    setError(void 0);
+  const fetchTeams = import_react7.useCallback(async (options) => {
+    setError(undefined);
     try {
       return await client.fetchTeams(options);
     } catch (err) {
@@ -1117,12 +1149,9 @@ function useAgnoActions() {
       throw err;
     }
   }, [client]);
-  const updateConfig = (0, import_react7.useCallback)(
-    (updates) => {
-      client.updateConfig(updates);
-    },
-    [client]
-  );
+  const updateConfig = import_react7.useCallback((updates) => {
+    client.updateConfig(updates);
+  }, [client]);
   return {
     initialize,
     checkStatus,
@@ -1133,15 +1162,14 @@ function useAgnoActions() {
     error
   };
 }
-
 // src/hooks/useAgnoCustomEvents.ts
 var import_react8 = require("react");
 function useAgnoCustomEvents(handler) {
   const client = useAgnoClient();
-  const [events, setEvents] = (0, import_react8.useState)([]);
-  const handlerRef = (0, import_react8.useRef)(handler);
+  const [events, setEvents] = import_react8.useState([]);
+  const handlerRef = import_react8.useRef(handler);
   handlerRef.current = handler;
-  (0, import_react8.useEffect)(() => {
+  import_react8.useEffect(() => {
     const handleCustomEvent = (event) => {
       setEvents((prev) => [...prev, event]);
       handlerRef.current?.(event);
@@ -1151,28 +1179,25 @@ function useAgnoCustomEvents(handler) {
       client.off("custom:event", handleCustomEvent);
     };
   }, [client]);
-  const clearEvents = (0, import_react8.useCallback)(() => {
+  const clearEvents = import_react8.useCallback(() => {
     setEvents([]);
   }, []);
   return { events, clearEvents };
 }
-
 // src/hooks/useAgnoMemory.ts
 var import_react9 = require("react");
 function useAgnoMemory() {
   const client = useAgnoClient();
-  const [memories, setMemories] = (0, import_react9.useState)([]);
-  const [topics, setTopics] = (0, import_react9.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)();
-  (0, import_react9.useEffect)(() => {
+  const [memories, setMemories] = import_react9.useState([]);
+  const [topics, setTopics] = import_react9.useState([]);
+  const [isLoading, setIsLoading] = import_react9.useState(false);
+  const [error, setError] = import_react9.useState();
+  import_react9.useEffect(() => {
     const handleMemoryCreated = (memory) => {
       setMemories((prev) => [memory, ...prev]);
     };
     const handleMemoryUpdated = (memory) => {
-      setMemories(
-        (prev) => prev.map((m) => m.memory_id === memory.memory_id ? memory : m)
-      );
+      setMemories((prev) => prev.map((m) => m.memory_id === memory.memory_id ? memory : m));
     };
     const handleMemoryDeleted = ({ memoryId }) => {
       setMemories((prev) => prev.filter((m) => m.memory_id !== memoryId));
@@ -1202,328 +1227,270 @@ function useAgnoMemory() {
       client.off("state:change", handleStateChange);
     };
   }, [client]);
-  const fetchMemories = (0, import_react9.useCallback)(
-    async (queryParams, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const response = await client.fetchMemories(queryParams, options);
-        setMemories(response.data);
-        return response;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getMemoryById = (0, import_react9.useCallback)(
-    async (memoryId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getMemoryById(memoryId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getMemoryTopics = (0, import_react9.useCallback)(
-    async (options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.getMemoryTopics(options);
-        setTopics(result);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getUserMemoryStats = (0, import_react9.useCallback)(
-    async (queryParams, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getUserMemoryStats(queryParams, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const createMemory = (0, import_react9.useCallback)(
-    async (request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.createMemory(request, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const updateMemory = (0, import_react9.useCallback)(
-    async (memoryId, request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.updateMemory(memoryId, request, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const deleteMemory = (0, import_react9.useCallback)(
-    async (memoryId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        await client.deleteMemory(memoryId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const deleteMultipleMemories = (0, import_react9.useCallback)(
-    async (memoryIds, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        await client.deleteMultipleMemories(memoryIds, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  return {
-    memories,
-    topics,
-    isLoading,
-    error,
-    fetchMemories,
-    getMemoryById,
-    getMemoryTopics,
-    getUserMemoryStats,
-    createMemory,
-    updateMemory,
-    deleteMemory,
-    deleteMultipleMemories
-  };
-}
-
-// src/hooks/useAgnoKnowledge.ts
+  const fetchMemories = import_react9.useCallback(async (queryParams, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const response = await client.fetchMemories(queryParams, options);
+      setMemories(response.data);
+      return response;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getMemoryById = import_react9.useCallback(async (memoryId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getMemoryById(memoryId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getMemoryTopics = import_react9.useCallback(async (options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.getMemoryTopics(options);
+      setTopics(result);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getUserMemoryStats = import_react9.useCallback(async (queryParams, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getUserMemoryStats(queryParams, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const createMemory = import_react9.useCallback(async (request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.createMemory(request, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const updateMemory = import_react9.useCallback(async (memoryId, request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.updateMemory(memoryId, request, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const deleteMemory = import_react9.useCallback(async (memoryId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      await client.deleteMemory(memoryId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const deleteMultipleMemories = import_react9.useCallback(async (memoryIds, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      await client.deleteMultipleMemories(memoryIds, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  return {
+    memories,
+    topics,
+    isLoading,
+    error,
+    fetchMemories,
+    getMemoryById,
+    getMemoryTopics,
+    getUserMemoryStats,
+    createMemory,
+    updateMemory,
+    deleteMemory,
+    deleteMultipleMemories
+  };
+}
+// src/hooks/useAgnoKnowledge.ts
 var import_react10 = require("react");
 function useAgnoKnowledge() {
   const client = useAgnoClient();
-  const [isLoading, setIsLoading] = (0, import_react10.useState)(false);
-  const [error, setError] = (0, import_react10.useState)();
-  const [config, setConfig] = (0, import_react10.useState)();
-  const [content, setContent] = (0, import_react10.useState)([]);
-  const getConfig = (0, import_react10.useCallback)(
-    async (options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.getKnowledgeConfig(options);
-        setConfig(result);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const listContent = (0, import_react10.useCallback)(
-    async (listOptions, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.listKnowledgeContent(listOptions, options);
-        setContent(result.data);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getContent = (0, import_react10.useCallback)(
-    async (contentId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getKnowledgeContent(contentId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getContentStatus = (0, import_react10.useCallback)(
-    async (contentId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getKnowledgeContentStatus(contentId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const search = (0, import_react10.useCallback)(
-    async (request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.searchKnowledge(request, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const uploadContent = (0, import_react10.useCallback)(
-    async (data, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.uploadKnowledgeContent(data, options);
-        setContent((prev) => [result, ...prev]);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const updateContent = (0, import_react10.useCallback)(
-    async (contentId, request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.updateKnowledgeContent(
-          contentId,
-          request,
-          options
-        );
-        setContent((prev) => prev.map((c) => c.id === contentId ? result : c));
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const deleteAllContent = (0, import_react10.useCallback)(
-    async (options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        await client.deleteAllKnowledgeContent(options);
-        setContent([]);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const deleteContent = (0, import_react10.useCallback)(
-    async (contentId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.deleteKnowledgeContent(contentId, options);
-        setContent((prev) => prev.filter((c) => c.id !== contentId));
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
+  const [isLoading, setIsLoading] = import_react10.useState(false);
+  const [error, setError] = import_react10.useState();
+  const [config, setConfig] = import_react10.useState();
+  const [content, setContent] = import_react10.useState([]);
+  const getConfig = import_react10.useCallback(async (options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.getKnowledgeConfig(options);
+      setConfig(result);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const listContent = import_react10.useCallback(async (listOptions, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.listKnowledgeContent(listOptions, options);
+      setContent(result.data);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getContent = import_react10.useCallback(async (contentId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getKnowledgeContent(contentId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getContentStatus = import_react10.useCallback(async (contentId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getKnowledgeContentStatus(contentId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const search = import_react10.useCallback(async (request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.searchKnowledge(request, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const uploadContent = import_react10.useCallback(async (data, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.uploadKnowledgeContent(data, options);
+      setContent((prev) => [result, ...prev]);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const updateContent = import_react10.useCallback(async (contentId, request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.updateKnowledgeContent(contentId, request, options);
+      setContent((prev) => prev.map((c) => c.id === contentId ? result : c));
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const deleteAllContent = import_react10.useCallback(async (options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      await client.deleteAllKnowledgeContent(options);
+      setContent([]);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const deleteContent = import_react10.useCallback(async (contentId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.deleteKnowledgeContent(contentId, options);
+      setContent((prev) => prev.filter((c) => c.id !== contentId));
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
   return {
-    // State
     config,
     content,
     isLoading,
     error,
-    // Methods
     getConfig,
     listContent,
     getContent,
@@ -1535,180 +1502,147 @@ function useAgnoKnowledge() {
     deleteContent
   };
 }
-
 // src/hooks/useAgnoMetrics.ts
 var import_react11 = require("react");
 function useAgnoMetrics() {
   const client = useAgnoClient();
-  const [isLoading, setIsLoading] = (0, import_react11.useState)(false);
-  const [isRefreshing, setIsRefreshing] = (0, import_react11.useState)(false);
-  const [error, setError] = (0, import_react11.useState)();
-  const [metrics, setMetrics] = (0, import_react11.useState)();
-  const fetchMetrics = (0, import_react11.useCallback)(
-    async (options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.fetchMetrics(options);
-        setMetrics(result);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const refreshMetrics = (0, import_react11.useCallback)(
-    async (options) => {
-      setIsRefreshing(true);
-      setError(void 0);
-      try {
-        const result = await client.refreshMetrics(options);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsRefreshing(false);
-      }
-    },
-    [client]
-  );
-  const clearMetrics = (0, import_react11.useCallback)(() => {
-    setMetrics(void 0);
-    setError(void 0);
+  const [isLoading, setIsLoading] = import_react11.useState(false);
+  const [isRefreshing, setIsRefreshing] = import_react11.useState(false);
+  const [error, setError] = import_react11.useState();
+  const [metrics, setMetrics] = import_react11.useState();
+  const fetchMetrics = import_react11.useCallback(async (options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.fetchMetrics(options);
+      setMetrics(result);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const refreshMetrics = import_react11.useCallback(async (options) => {
+    setIsRefreshing(true);
+    setError(undefined);
+    try {
+      const result = await client.refreshMetrics(options);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsRefreshing(false);
+    }
+  }, [client]);
+  const clearMetrics = import_react11.useCallback(() => {
+    setMetrics(undefined);
+    setError(undefined);
   }, []);
   return {
-    // Data
     metrics,
-    // Actions
     fetchMetrics,
     refreshMetrics,
     clearMetrics,
-    // State
     isLoading,
     isRefreshing,
     error
   };
 }
-
 // src/hooks/useAgnoEvals.ts
 var import_react12 = require("react");
 function useAgnoEvals() {
   const client = useAgnoClient();
-  const [evalRuns, setEvalRuns] = (0, import_react12.useState)([]);
-  const [pagination, setPagination] = (0, import_react12.useState)();
-  const [isLoading, setIsLoading] = (0, import_react12.useState)(false);
-  const [error, setError] = (0, import_react12.useState)();
-  const listEvalRuns = (0, import_react12.useCallback)(
-    async (listParams = {}, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const response = await client.listEvalRuns(listParams, options);
-        setEvalRuns(response.data);
-        setPagination(response.meta);
-        return response;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getEvalRun = (0, import_react12.useCallback)(
-    async (evalRunId, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getEvalRun(evalRunId, options);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const executeEval = (0, import_react12.useCallback)(
-    async (request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.executeEval(request, options);
-        setEvalRuns((prev) => [result, ...prev]);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const updateEvalRun = (0, import_react12.useCallback)(
-    async (evalRunId, request, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.updateEvalRun(evalRunId, request, options);
-        setEvalRuns(
-          (prev) => prev.map((evalRun) => evalRun.id === evalRunId ? result : evalRun)
-        );
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const deleteEvalRuns = (0, import_react12.useCallback)(
-    async (evalRunIds, options) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        await client.deleteEvalRuns(evalRunIds, options);
-        const deletedSet = new Set(evalRunIds);
-        setEvalRuns((prev) => prev.filter((evalRun) => !deletedSet.has(evalRun.id)));
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const renameEvalRun = (0, import_react12.useCallback)(
-    async (evalRunId, newName, options) => {
-      return updateEvalRun(evalRunId, { name: newName }, options);
-    },
-    [updateEvalRun]
-  );
+  const [evalRuns, setEvalRuns] = import_react12.useState([]);
+  const [pagination, setPagination] = import_react12.useState();
+  const [isLoading, setIsLoading] = import_react12.useState(false);
+  const [error, setError] = import_react12.useState();
+  const listEvalRuns = import_react12.useCallback(async (listParams = {}, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const response = await client.listEvalRuns(listParams, options);
+      setEvalRuns(response.data);
+      setPagination(response.meta);
+      return response;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getEvalRun = import_react12.useCallback(async (evalRunId, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getEvalRun(evalRunId, options);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const executeEval = import_react12.useCallback(async (request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.executeEval(request, options);
+      setEvalRuns((prev) => [result, ...prev]);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const updateEvalRun = import_react12.useCallback(async (evalRunId, request, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.updateEvalRun(evalRunId, request, options);
+      setEvalRuns((prev) => prev.map((evalRun) => evalRun.id === evalRunId ? result : evalRun));
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const deleteEvalRuns = import_react12.useCallback(async (evalRunIds, options) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      await client.deleteEvalRuns(evalRunIds, options);
+      const deletedSet = new Set(evalRunIds);
+      setEvalRuns((prev) => prev.filter((evalRun) => !deletedSet.has(evalRun.id)));
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const renameEvalRun = import_react12.useCallback(async (evalRunId, newName, options) => {
+    return updateEvalRun(evalRunId, { name: newName }, options);
+  }, [updateEvalRun]);
   return {
-    // State
     evalRuns,
     pagination,
     isLoading,
     error,
-    // Methods
     listEvalRuns,
     getEvalRun,
     executeEval,
@@ -1717,16 +1651,15 @@ function useAgnoEvals() {
     renameEvalRun
   };
 }
-
 // src/hooks/useAgnoTraces.ts
 var import_react13 = require("react");
 function useAgnoTraces() {
   const client = useAgnoClient();
-  const [traces, setTraces] = (0, import_react13.useState)([]);
-  const [traceSessionStats, setTraceSessionStats] = (0, import_react13.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react13.useState)(false);
-  const [error, setError] = (0, import_react13.useState)();
-  (0, import_react13.useEffect)(() => {
+  const [traces, setTraces] = import_react13.useState([]);
+  const [traceSessionStats, setTraceSessionStats] = import_react13.useState([]);
+  const [isLoading, setIsLoading] = import_react13.useState(false);
+  const [error, setError] = import_react13.useState();
+  import_react13.useEffect(() => {
     const handleStateChange = () => {
       const state2 = client.getState();
       setTraces(state2.traces);
@@ -1740,111 +1673,58 @@ function useAgnoTraces() {
       client.off("state:change", handleStateChange);
     };
   }, [client]);
-  const fetchTraces = (0, import_react13.useCallback)(
-    async (options = {}, requestOptions) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.fetchTraces(options, requestOptions);
-        setTraces(result.traces);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const getTraceDetail = (0, import_react13.useCallback)(
-    async (traceId, options = {}, requestOptions) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        return await client.getTraceDetail(traceId, options, requestOptions);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
-  const fetchTraceSessionStats = (0, import_react13.useCallback)(
-    async (options = {}, requestOptions) => {
-      setIsLoading(true);
-      setError(void 0);
-      try {
-        const result = await client.fetchTraceSessionStats(options, requestOptions);
-        setTraceSessionStats(result.stats);
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client]
-  );
+  const fetchTraces = import_react13.useCallback(async (options = {}, requestOptions) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.fetchTraces(options, requestOptions);
+      setTraces(result.traces);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getTraceDetail = import_react13.useCallback(async (traceId, options = {}, requestOptions) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      return await client.getTraceDetail(traceId, options, requestOptions);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const fetchTraceSessionStats = import_react13.useCallback(async (options = {}, requestOptions) => {
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await client.fetchTraceSessionStats(options, requestOptions);
+      setTraceSessionStats(result.stats);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
   return {
-    /** Current list of traces (from last fetchTraces call) */
     traces,
-    /** Current trace session statistics (from last fetchTraceSessionStats call) */
     traceSessionStats,
-    /** Fetch traces with optional filters and pagination */
     fetchTraces,
-    /** Get trace detail or specific span */
     getTraceDetail,
-    /** Fetch trace session statistics */
     fetchTraceSessionStats,
-    /** Loading state */
     isLoading,
-    /** Error message if last operation failed */
     error
   };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AgnoProvider,
-  ComponentRegistry,
-  GenerativeUIRenderer,
-  ToolHandlerProvider,
-  createAreaChart,
-  createArtifact,
-  createBarChart,
-  createCard,
-  createCardGrid,
-  createColumn,
-  createLineChart,
-  createMarkdown,
-  createPieChart,
-  createSmartChart,
-  createTable,
-  createToolResult,
-  getChartComponent,
-  getComponentRegistry,
-  getCustomRender,
-  registerChartComponent,
-  resultWithBarChart,
-  resultWithCardGrid,
-  resultWithSmartChart,
-  resultWithTable,
-  useAgnoActions,
-  useAgnoChat,
-  useAgnoClient,
-  useAgnoCustomEvents,
-  useAgnoEvals,
-  useAgnoKnowledge,
-  useAgnoMemory,
-  useAgnoMetrics,
-  useAgnoSession,
-  useAgnoToolExecution,
-  useAgnoTraces,
-  useToolHandlers
-});
+
+//# debugId=7C493B5C15A68B3E64756E2164756E21