@rodrigocoliveira/agno-react 1.0.2 → 1.1.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // src/context/AgnoContext.tsx
 import { createContext, useContext, useMemo, useEffect } from "react";
 import { AgnoClient } from "@rodrigocoliveira/agno-client";
-import { jsx } from "react/jsx-runtime";
+import { jsxDEV } from "react/jsx-dev-runtime";
 var AgnoContext = createContext(null);
 function AgnoProvider({ config, children }) {
   const client = useMemo(() => new AgnoClient(config), []);
@@ -13,7 +13,10 @@ function AgnoProvider({ config, children }) {
       client.removeAllListeners();
     };
   }, [client]);
-  return /* @__PURE__ */ jsx(AgnoContext.Provider, { value: client, children });
+  return /* @__PURE__ */ jsxDEV(AgnoContext.Provider, {
+    value: client,
+    children
+  }, undefined, false, undefined, this);
 }
 function useAgnoClient() {
   const client = useContext(AgnoContext);
@@ -22,10 +25,9 @@ function useAgnoClient() {
   }
   return client;
 }
-
 // src/context/ToolHandlerContext.tsx
 import { createContext as createContext2, useContext as useContext2, useState, useCallback } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
 var ToolHandlerContext = createContext2(null);
 function ToolHandlerProvider({ handlers: initialHandlers = {}, children }) {
   const [handlers, setHandlers] = useState(initialHandlers);
@@ -43,74 +45,52 @@ function ToolHandlerProvider({ handlers: initialHandlers = {}, children }) {
     registerHandler,
     unregisterHandler
   };
-  return /* @__PURE__ */ jsx2(ToolHandlerContext.Provider, { value, children });
+  return /* @__PURE__ */ jsxDEV2(ToolHandlerContext.Provider, {
+    value,
+    children
+  }, undefined, false, undefined, this);
 }
 function useToolHandlers() {
   return useContext2(ToolHandlerContext);
 }
-
 // src/components/GenerativeUIRenderer.tsx
 import React3 from "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();
 }
@@ -123,7 +103,7 @@ function getChartComponent(name) {
 
 // src/hooks/useAgnoToolExecution.ts
 import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useMemo as useMemo2 } from "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);
@@ -133,7 +113,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;
@@ -141,15 +121,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;
@@ -167,7 +146,7 @@ function processToolResult(result, _tool) {
       uiComponent = {
         ...result,
         renderKey,
-        render: void 0
+        render: undefined
       };
     } else {
       uiComponent = result;
@@ -179,7 +158,7 @@ function processToolResult(result, _tool) {
   }
   return {
     resultData: typeof result === "string" ? result : JSON.stringify(result),
-    uiComponent: void 0
+    uiComponent: undefined
   };
 }
 function useAgnoToolExecution(handlers = {}, autoExecute = true) {
@@ -188,9 +167,7 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
   const isTeamMode = client.getConfig().mode === "team";
   useEffect2(() => {
     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 = useMemo2(() => {
@@ -208,13 +185,13 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
     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);
@@ -229,37 +206,35 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
       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", {
@@ -280,11 +255,14 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
     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);
@@ -302,74 +280,61 @@ function useAgnoToolExecution(handlers = {}, autoExecute = true) {
       client.off("session:loaded", handleSessionLoaded);
     };
   }, [client, mergedHandlers]);
-  const executeTools = useCallback2(
-    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 = useCallback2(
-    async (tools, options) => {
-      if (!isPaused) {
-        throw new Error("No paused run to continue");
-      }
-      setIsExecuting(true);
+  const executeTools = useCallback2(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]
-  );
+    }));
+  }, [mergedHandlers]);
+  const continueWithResults = useCallback2(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]);
   useEffect2(() => {
     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
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
-var UIErrorBoundary = class extends React3.Component {
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+
+class UIErrorBoundary extends React3.Component {
   constructor(props) {
     super(props);
     this.state = { hasError: false };
@@ -383,14 +348,23 @@ var UIErrorBoundary = class extends React3.Component {
   }
   render() {
     if (this.state.hasError) {
-      return this.props.fallback || /* @__PURE__ */ jsxs("div", { className: "p-4 border border-red-300 rounded-md bg-red-50 text-red-800", children: [
-        /* @__PURE__ */ jsx3("p", { className: "font-semibold", children: "Failed to render UI component" }),
-        /* @__PURE__ */ jsx3("p", { className: "text-sm mt-1", children: this.state.error?.message || "Unknown error" })
-      ] });
+      return this.props.fallback || /* @__PURE__ */ jsxDEV3("div", {
+        className: "p-4 border border-red-300 rounded-md bg-red-50 text-red-800",
+        children: [
+          /* @__PURE__ */ jsxDEV3("p", {
+            className: "font-semibold",
+            children: "Failed to render UI component"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("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,
@@ -402,78 +376,184 @@ function GenerativeUIRenderer({
     if (customSpec.renderKey) {
       const renderFn = getCustomRender(customSpec.renderKey);
       if (renderFn) {
-        return /* @__PURE__ */ jsx3(UIErrorBoundary, { onError, children: /* @__PURE__ */ jsx3("div", { className, children: renderFn(customSpec.props || {}) }) });
+        return /* @__PURE__ */ jsxDEV3(UIErrorBoundary, {
+          onError,
+          children: /* @__PURE__ */ jsxDEV3("div", {
+            className,
+            children: renderFn(customSpec.props || {})
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this);
       }
     }
-    return /* @__PURE__ */ jsxs("div", { className: `p-4 border border-yellow-300 rounded-md bg-yellow-50 text-yellow-800 ${className || ""}`, children: [
-      /* @__PURE__ */ jsx3("p", { className: "font-semibold", children: "Custom component not available" }),
-      /* @__PURE__ */ jsx3("p", { className: "text-sm mt-1", children: "The custom render function for this component is not available." })
-    ] });
+    return /* @__PURE__ */ jsxDEV3("div", {
+      className: `p-4 border border-yellow-300 rounded-md bg-yellow-50 text-yellow-800 ${className || ""}`,
+      children: [
+        /* @__PURE__ */ jsxDEV3("p", {
+          className: "font-semibold",
+          children: "Custom component not available"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV3("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__ */ jsx3(UIErrorBoundary, { onError, children: /* @__PURE__ */ jsxs("div", { className, children: [
-        chartSpec.title && /* @__PURE__ */ jsx3("h3", { className: "font-semibold mb-2", children: chartSpec.title }),
-        chartSpec.description && /* @__PURE__ */ jsx3("p", { className: "text-sm text-gray-600 mb-4", children: chartSpec.description }),
-        /* @__PURE__ */ jsx3(ChartRenderer, { ...chartSpec.props })
-      ] }) });
-    }
-    return /* @__PURE__ */ jsxs("div", { className: `p-4 border border-gray-300 rounded-md ${className || ""}`, children: [
-      /* @__PURE__ */ jsx3("p", { className: "font-semibold mb-2", children: chartSpec.title || "Chart Data" }),
-      chartSpec.description && /* @__PURE__ */ jsx3("p", { className: "text-sm text-gray-600 mb-2", children: chartSpec.description }),
-      /* @__PURE__ */ jsx3("pre", { className: "text-xs bg-gray-100 p-2 rounded overflow-auto", children: JSON.stringify(chartSpec.props.data, null, 2) })
-    ] });
+      return /* @__PURE__ */ jsxDEV3(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsxDEV3("div", {
+          className,
+          children: [
+            chartSpec.title && /* @__PURE__ */ jsxDEV3("h3", {
+              className: "font-semibold mb-2",
+              children: chartSpec.title
+            }, undefined, false, undefined, this),
+            chartSpec.description && /* @__PURE__ */ jsxDEV3("p", {
+              className: "text-sm text-gray-600 mb-4",
+              children: chartSpec.description
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV3(ChartRenderer, {
+              ...chartSpec.props
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this);
+    }
+    return /* @__PURE__ */ jsxDEV3("div", {
+      className: `p-4 border border-gray-300 rounded-md ${className || ""}`,
+      children: [
+        /* @__PURE__ */ jsxDEV3("p", {
+          className: "font-semibold mb-2",
+          children: chartSpec.title || "Chart Data"
+        }, undefined, false, undefined, this),
+        chartSpec.description && /* @__PURE__ */ jsxDEV3("p", {
+          className: "text-sm text-gray-600 mb-2",
+          children: chartSpec.description
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV3("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__ */ jsx3(UIErrorBoundary, { onError, children: /* @__PURE__ */ jsxs("div", { className, children: [
-        cardGridSpec.title && /* @__PURE__ */ jsx3("h3", { className: "font-semibold mb-2", children: cardGridSpec.title }),
-        cardGridSpec.description && /* @__PURE__ */ jsx3("p", { className: "text-sm text-gray-600 mb-4", children: cardGridSpec.description }),
-        /* @__PURE__ */ jsx3(CardGridRenderer, { ...cardGridSpec.props })
-      ] }) });
+      return /* @__PURE__ */ jsxDEV3(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsxDEV3("div", {
+          className,
+          children: [
+            cardGridSpec.title && /* @__PURE__ */ jsxDEV3("h3", {
+              className: "font-semibold mb-2",
+              children: cardGridSpec.title
+            }, undefined, false, undefined, this),
+            cardGridSpec.description && /* @__PURE__ */ jsxDEV3("p", {
+              className: "text-sm text-gray-600 mb-4",
+              children: cardGridSpec.description
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV3(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__ */ jsx3(UIErrorBoundary, { onError, children: /* @__PURE__ */ jsxs("div", { className, children: [
-        tableSpec.title && /* @__PURE__ */ jsx3("h3", { className: "font-semibold mb-2", children: tableSpec.title }),
-        tableSpec.description && /* @__PURE__ */ jsx3("p", { className: "text-sm text-gray-600 mb-4", children: tableSpec.description }),
-        /* @__PURE__ */ jsx3(TableRenderer, { ...tableSpec.props })
-      ] }) });
+      return /* @__PURE__ */ jsxDEV3(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsxDEV3("div", {
+          className,
+          children: [
+            tableSpec.title && /* @__PURE__ */ jsxDEV3("h3", {
+              className: "font-semibold mb-2",
+              children: tableSpec.title
+            }, undefined, false, undefined, this),
+            tableSpec.description && /* @__PURE__ */ jsxDEV3("p", {
+              className: "text-sm text-gray-600 mb-4",
+              children: tableSpec.description
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV3(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__ */ jsx3(UIErrorBoundary, { onError, children: /* @__PURE__ */ jsx3("div", { className, children: /* @__PURE__ */ jsx3(MarkdownRenderer, { ...markdownSpec.props }) }) });
+      return /* @__PURE__ */ jsxDEV3(UIErrorBoundary, {
+        onError,
+        children: /* @__PURE__ */ jsxDEV3("div", {
+          className,
+          children: /* @__PURE__ */ jsxDEV3(MarkdownRenderer, {
+            ...markdownSpec.props
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this);
     }
-    return /* @__PURE__ */ jsx3("div", { className, children: markdownSpec.props.content });
+    return /* @__PURE__ */ jsxDEV3("div", {
+      className,
+      children: markdownSpec.props.content
+    }, undefined, false, undefined, this);
   }
   if (spec.type === "artifact") {
     const artifactSpec = spec;
-    return /* @__PURE__ */ jsx3(UIErrorBoundary, { onError, children: /* @__PURE__ */ jsxs("div", { className: `p-4 border rounded-md ${className || ""}`, children: [
-      artifactSpec.title && /* @__PURE__ */ jsx3("h3", { className: "font-semibold mb-4", children: artifactSpec.title }),
-      artifactSpec.description && /* @__PURE__ */ jsx3("p", { className: "text-sm text-gray-600 mb-4", children: artifactSpec.description }),
-      /* @__PURE__ */ jsx3("div", { className: "space-y-4", children: artifactSpec.props.content?.map((childSpec, index) => /* @__PURE__ */ jsx3(GenerativeUIRenderer, { spec: childSpec, onError }, index)) })
-    ] }) });
+    return /* @__PURE__ */ jsxDEV3(UIErrorBoundary, {
+      onError,
+      children: /* @__PURE__ */ jsxDEV3("div", {
+        className: `p-4 border rounded-md ${className || ""}`,
+        children: [
+          artifactSpec.title && /* @__PURE__ */ jsxDEV3("h3", {
+            className: "font-semibold mb-4",
+            children: artifactSpec.title
+          }, undefined, false, undefined, this),
+          artifactSpec.description && /* @__PURE__ */ jsxDEV3("p", {
+            className: "text-sm text-gray-600 mb-4",
+            children: artifactSpec.description
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("div", {
+            className: "space-y-4",
+            children: artifactSpec.props.content?.map((childSpec, index) => /* @__PURE__ */ jsxDEV3(GenerativeUIRenderer, {
+              spec: childSpec,
+              onError
+            }, index, false, undefined, this))
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
   }
-  return /* @__PURE__ */ jsxs("div", { className: `p-4 border border-gray-300 rounded-md ${className || ""}`, children: [
-    /* @__PURE__ */ jsx3("p", { className: "font-semibold", children: "Unsupported UI component" }),
-    /* @__PURE__ */ jsxs("p", { className: "text-sm text-gray-600 mt-1", children: [
-      "Component type: ",
-      spec.type
-    ] })
-  ] });
+  return /* @__PURE__ */ jsxDEV3("div", {
+    className: `p-4 border border-gray-300 rounded-md ${className || ""}`,
+    children: [
+      /* @__PURE__ */ jsxDEV3("p", {
+        className: "font-semibold",
+        children: "Unsupported UI component"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV3("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 {
@@ -639,34 +719,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);
     }
@@ -675,19 +738,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 };
@@ -704,14 +757,12 @@ function resultWithCardGrid(cards, options) {
 function resultWithTable(data, columns, options) {
   return createToolResult(data, createTable(data, columns, options));
 }
-
 // src/hooks/useAgnoChat.ts
 import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3 } from "react";
 function useAgnoChat() {
   const client = useAgnoClient();
   const [messages, setMessages] = useState3(client.getMessages());
   const [state, setState] = useState3(client.getState());
-  const [error, setError] = useState3();
   useEffect3(() => {
     const handleMessageUpdate = (updatedMessages) => {
       setMessages(updatedMessages);
@@ -722,9 +773,6 @@ function useAgnoChat() {
     const handleMessageRefreshed = (updatedMessages) => {
       setMessages(updatedMessages);
     };
-    const handleMessageError = (errorMessage) => {
-      setError(errorMessage);
-    };
     const handleStateChange = (newState) => {
       setState(newState);
     };
@@ -736,12 +784,10 @@ function useAgnoChat() {
         }
       }
     };
-    const handleRunCancelled = () => {
-    };
+    const handleRunCancelled = () => {};
     client.on("message:update", handleMessageUpdate);
     client.on("message:complete", handleMessageComplete);
     client.on("message:refreshed", handleMessageRefreshed);
-    client.on("message:error", handleMessageError);
     client.on("state:change", handleStateChange);
     client.on("ui:render", handleUIRender);
     client.on("run:cancelled", handleRunCancelled);
@@ -751,38 +797,24 @@ function useAgnoChat() {
       client.off("message:update", handleMessageUpdate);
       client.off("message:complete", handleMessageComplete);
       client.off("message:refreshed", handleMessageRefreshed);
-      client.off("message:error", handleMessageError);
       client.off("state:change", handleStateChange);
       client.off("ui:render", handleUIRender);
       client.off("run:cancelled", handleRunCancelled);
     };
   }, [client]);
-  const sendMessage = useCallback3(
-    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 sendMessage = useCallback3(async (message, options) => {
+    try {
+      await client.sendMessage(message, options);
+    } catch (err) {
+      throw err;
+    }
+  }, [client]);
   const clearMessages = useCallback3(() => {
     client.clearMessages();
     setMessages([]);
-    setError(void 0);
   }, [client]);
   const cancelRun = useCallback3(async () => {
-    try {
-      await client.cancelRun();
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      setError(errorMessage);
-      throw err;
-    }
+    await client.cancelRun();
   }, [client]);
   return {
     messages,
@@ -794,19 +826,16 @@ function useAgnoChat() {
     isPaused: state.isPaused,
     isCancelling: state.isCancelling,
     currentRunId: state.currentRunId,
-    error,
+    error: state.errorMessage,
     state
   };
 }
-
 // src/hooks/useAgnoSession.ts
 import { useState as useState4, useEffect as useEffect4, useCallback as useCallback4 } from "react";
 function useAgnoSession() {
   const client = useAgnoClient();
   const [sessions, setSessions] = useState4([]);
-  const [currentSessionId, setCurrentSessionId] = useState4(
-    client.getConfig().sessionId
-  );
+  const [currentSessionId, setCurrentSessionId] = useState4(client.getConfig().sessionId);
   const [isLoading, setIsLoading] = useState4(false);
   const [error, setError] = useState4();
   useEffect4(() => {
@@ -833,27 +862,24 @@ function useAgnoSession() {
       client.off("state:change", handleStateChange);
     };
   }, [client]);
-  const loadSession = useCallback4(
-    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 loadSession = useCallback4(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 = useCallback4(async (options) => {
     setIsLoading(true);
-    setError(void 0);
+    setError(undefined);
     try {
       const fetchedSessions = await client.fetchSessions(options);
       setSessions(fetchedSessions);
@@ -866,119 +892,98 @@ function useAgnoSession() {
       setIsLoading(false);
     }
   }, [client]);
-  const getSessionById = useCallback4(
-    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 = useCallback4(
-    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 = useCallback4(
-    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 = useCallback4(
-    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 = useCallback4(
-    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 = useCallback4(
-    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 = useCallback4(
-    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 = useCallback4(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 = useCallback4(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 = useCallback4(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 = useCallback4(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 = useCallback4(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 = useCallback4(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 = useCallback4(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,
@@ -995,7 +1000,6 @@ function useAgnoSession() {
     error
   };
 }
-
 // src/hooks/useAgnoActions.ts
 import { useState as useState5, useCallback as useCallback5 } from "react";
 function useAgnoActions() {
@@ -1004,7 +1008,7 @@ function useAgnoActions() {
   const [error, setError] = useState5();
   const initialize = useCallback5(async (options) => {
     setIsInitializing(true);
-    setError(void 0);
+    setError(undefined);
     try {
       const result = await client.initialize(options);
       return result;
@@ -1017,7 +1021,7 @@ function useAgnoActions() {
     }
   }, [client]);
   const checkStatus = useCallback5(async (options) => {
-    setError(void 0);
+    setError(undefined);
     try {
       return await client.checkStatus(options);
     } catch (err) {
@@ -1027,7 +1031,7 @@ function useAgnoActions() {
     }
   }, [client]);
   const fetchAgents = useCallback5(async (options) => {
-    setError(void 0);
+    setError(undefined);
     try {
       return await client.fetchAgents(options);
     } catch (err) {
@@ -1037,7 +1041,7 @@ function useAgnoActions() {
     }
   }, [client]);
   const fetchTeams = useCallback5(async (options) => {
-    setError(void 0);
+    setError(undefined);
     try {
       return await client.fetchTeams(options);
     } catch (err) {
@@ -1046,12 +1050,9 @@ function useAgnoActions() {
       throw err;
     }
   }, [client]);
-  const updateConfig = useCallback5(
-    (updates) => {
-      client.updateConfig(updates);
-    },
-    [client]
-  );
+  const updateConfig = useCallback5((updates) => {
+    client.updateConfig(updates);
+  }, [client]);
   return {
     initialize,
     checkStatus,
@@ -1062,7 +1063,6 @@ function useAgnoActions() {
     error
   };
 }
-
 // src/hooks/useAgnoCustomEvents.ts
 import { useState as useState6, useEffect as useEffect5, useCallback as useCallback6, useRef } from "react";
 function useAgnoCustomEvents(handler) {
@@ -1085,7 +1085,6 @@ function useAgnoCustomEvents(handler) {
   }, []);
   return { events, clearEvents };
 }
-
 // src/hooks/useAgnoMemory.ts
 import { useState as useState7, useEffect as useEffect6, useCallback as useCallback7 } from "react";
 function useAgnoMemory() {
@@ -1099,9 +1098,7 @@ function useAgnoMemory() {
       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));
@@ -1131,138 +1128,114 @@ function useAgnoMemory() {
       client.off("state:change", handleStateChange);
     };
   }, [client]);
-  const fetchMemories = useCallback7(
-    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 = useCallback7(
-    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 = useCallback7(
-    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 = useCallback7(
-    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 = useCallback7(
-    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 = useCallback7(
-    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 = useCallback7(
-    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 = useCallback7(
-    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]
-  );
+  const fetchMemories = useCallback7(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 = useCallback7(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 = useCallback7(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 = useCallback7(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 = useCallback7(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 = useCallback7(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 = useCallback7(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 = useCallback7(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,
@@ -1278,7 +1251,6 @@ function useAgnoMemory() {
     deleteMultipleMemories
   };
 }
-
 // src/hooks/useAgnoKnowledge.ts
 import { useState as useState8, useCallback as useCallback8 } from "react";
 function useAgnoKnowledge() {
@@ -1287,172 +1259,139 @@ function useAgnoKnowledge() {
   const [error, setError] = useState8();
   const [config, setConfig] = useState8();
   const [content, setContent] = useState8([]);
-  const getConfig = useCallback8(
-    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 = useCallback8(
-    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 = useCallback8(
-    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 = useCallback8(
-    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 = useCallback8(
-    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 = useCallback8(
-    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 = useCallback8(
-    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 = useCallback8(
-    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 = useCallback8(
-    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 getConfig = useCallback8(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 = useCallback8(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 = useCallback8(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 = useCallback8(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 = useCallback8(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 = useCallback8(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 = useCallback8(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 = useCallback8(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 = useCallback8(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,
@@ -1464,7 +1403,6 @@ function useAgnoKnowledge() {
     deleteContent
   };
 }
-
 // src/hooks/useAgnoMetrics.ts
 import { useState as useState9, useCallback as useCallback9 } from "react";
 function useAgnoMetrics() {
@@ -1473,59 +1411,49 @@ function useAgnoMetrics() {
   const [isRefreshing, setIsRefreshing] = useState9(false);
   const [error, setError] = useState9();
   const [metrics, setMetrics] = useState9();
-  const fetchMetrics = useCallback9(
-    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 = useCallback9(
-    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 fetchMetrics = useCallback9(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 = useCallback9(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 = useCallback9(() => {
-    setMetrics(void 0);
-    setError(void 0);
+    setMetrics(undefined);
+    setError(undefined);
   }, []);
   return {
-    // Data
     metrics,
-    // Actions
     fetchMetrics,
     refreshMetrics,
     clearMetrics,
-    // State
     isLoading,
     isRefreshing,
     error
   };
 }
-
 // src/hooks/useAgnoEvals.ts
 import { useState as useState10, useCallback as useCallback10 } from "react";
 function useAgnoEvals() {
@@ -1534,110 +1462,88 @@ function useAgnoEvals() {
   const [pagination, setPagination] = useState10();
   const [isLoading, setIsLoading] = useState10(false);
   const [error, setError] = useState10();
-  const listEvalRuns = useCallback10(
-    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 = useCallback10(
-    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 = useCallback10(
-    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 = useCallback10(
-    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 = useCallback10(
-    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 = useCallback10(
-    async (evalRunId, newName, options) => {
-      return updateEvalRun(evalRunId, { name: newName }, options);
-    },
-    [updateEvalRun]
-  );
+  const listEvalRuns = useCallback10(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 = useCallback10(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 = useCallback10(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 = useCallback10(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 = useCallback10(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 = useCallback10(async (evalRunId, newName, options) => {
+    return updateEvalRun(evalRunId, { name: newName }, options);
+  }, [updateEvalRun]);
   return {
-    // State
     evalRuns,
     pagination,
     isLoading,
     error,
-    // Methods
     listEvalRuns,
     getEvalRun,
     executeEval,
@@ -1646,7 +1552,6 @@ function useAgnoEvals() {
     renameEvalRun
   };
 }
-
 // src/hooks/useAgnoTraces.ts
 import { useState as useState11, useEffect as useEffect7, useCallback as useCallback11 } from "react";
 function useAgnoTraces() {
@@ -1669,110 +1574,96 @@ function useAgnoTraces() {
       client.off("state:change", handleStateChange);
     };
   }, [client]);
-  const fetchTraces = useCallback11(
-    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 = useCallback11(
-    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 = useCallback11(
-    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 = useCallback11(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 = useCallback11(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 = useCallback11(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
   };
 }
 export {
-  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,
+  useToolHandlers,
   useAgnoTraces,
-  useToolHandlers
+  useAgnoToolExecution,
+  useAgnoSession,
+  useAgnoMetrics,
+  useAgnoMemory,
+  useAgnoKnowledge,
+  useAgnoEvals,
+  useAgnoCustomEvents,
+  useAgnoClient,
+  useAgnoChat,
+  useAgnoActions,
+  resultWithTable,
+  resultWithSmartChart,
+  resultWithCardGrid,
+  resultWithBarChart,
+  registerChartComponent,
+  getCustomRender,
+  getComponentRegistry,
+  getChartComponent,
+  createToolResult,
+  createTable,
+  createSmartChart,
+  createPieChart,
+  createMarkdown,
+  createLineChart,
+  createColumn,
+  createCardGrid,
+  createCard,
+  createBarChart,
+  createArtifact,
+  createAreaChart,
+  ToolHandlerProvider,
+  GenerativeUIRenderer,
+  ComponentRegistry,
+  AgnoProvider
 };
+
+//# debugId=414F45CD3B3482F064756E2164756E21