@antipopp/agno-react 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -20,35 +20,687 @@ 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";
+var ToolHandlerContext = createContext2(null);
+function ToolHandlerProvider({ handlers: initialHandlers = {}, children }) {
+  const [handlers, setHandlers] = useState(initialHandlers);
+  const registerHandler = useCallback((name, handler) => {
+    setHandlers((prev) => ({ ...prev, [name]: handler }));
+  }, []);
+  const unregisterHandler = useCallback((name) => {
+    setHandlers((prev) => {
+      const { [name]: _, ...rest } = prev;
+      return rest;
+    });
+  }, []);
+  const value = {
+    handlers,
+    registerHandler,
+    unregisterHandler
+  };
+  return /* @__PURE__ */ jsx2(ToolHandlerContext.Provider, { value, children });
+}
+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
+   */
+  static getInstance() {
+    if (!_ComponentRegistry.instance) {
+      _ComponentRegistry.instance = new _ComponentRegistry();
+    }
+    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();
+}
+function registerChartComponent(name, renderer) {
+  getComponentRegistry().register(`chart:${name}`, renderer);
+}
+function getChartComponent(name) {
+  return getComponentRegistry().get(`chart:${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();
+function registerCustomRender(renderFn) {
+  const key = `custom-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  customRenderRegistry.set(key, renderFn);
+  return key;
+}
+function getCustomRender(key) {
+  return customRenderRegistry.get(key);
+}
+function isToolHandlerResult(value) {
+  return value && typeof value === "object" && ("data" in value || "ui" in value);
+}
+function isUIComponentSpec(value) {
+  return value && typeof value === "object" && "type" in value;
+}
+function processToolResult(result, _tool) {
+  if (isToolHandlerResult(result)) {
+    const { data, ui } = result;
+    let uiComponent = void 0;
+    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
+        };
+      } else {
+        uiComponent = ui;
+      }
+    }
+    return {
+      resultData: typeof data === "string" ? data : JSON.stringify(data),
+      uiComponent
+    };
+  }
+  if (isUIComponentSpec(result)) {
+    let uiComponent;
+    if (result.type === "custom" && typeof result.render === "function") {
+      const renderKey = registerCustomRender(result.render);
+      uiComponent = {
+        ...result,
+        renderKey,
+        render: void 0
+      };
+    } else {
+      uiComponent = result;
+    }
+    return {
+      resultData: JSON.stringify(result),
+      uiComponent
+    };
+  }
+  return {
+    resultData: typeof result === "string" ? result : JSON.stringify(result),
+    uiComponent: void 0
+  };
+}
+function useAgnoToolExecution(handlers = {}, autoExecute = true) {
+  const client = useAgnoClient();
+  const toolHandlerContext = useToolHandlers();
+  const mergedHandlers = useMemo2(() => {
+    const globalHandlers = toolHandlerContext?.handlers || {};
+    return { ...globalHandlers, ...handlers };
+  }, [toolHandlerContext?.handlers, handlers]);
+  const [pendingTools, setPendingTools] = useState2([]);
+  const [isPaused, setIsPaused] = useState2(false);
+  const [isExecuting, setIsExecuting] = useState2(false);
+  const [executionError, setExecutionError] = useState2();
+  useEffect2(() => {
+    const handleRunPaused = (event) => {
+      setIsPaused(true);
+      setPendingTools(event.tools);
+      setExecutionError(void 0);
+    };
+    const handleRunContinued = () => {
+      setIsPaused(false);
+      setPendingTools([]);
+      setIsExecuting(false);
+      setExecutionError(void 0);
+    };
+    client.on("run:paused", handleRunPaused);
+    client.on("run:continued", handleRunContinued);
+    return () => {
+      client.off("run:paused", handleRunPaused);
+      client.off("run:continued", handleRunContinued);
+    };
+  }, [client]);
+  const executeAndContinue = useCallback2(async () => {
+    if (!isPaused || pendingTools.length === 0) {
+      console.warn("[useAgnoToolExecution] Cannot execute: no pending tools");
+      return;
+    }
+    setIsExecuting(true);
+    setExecutionError(void 0);
+    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 toolsWithUI = updatedTools.filter((t) => t.ui_component);
+      if (toolsWithUI.length > 0) {
+        client.emit("ui:render", {
+          tools: updatedTools,
+          runId: client.getState().pausedRunId
+        });
+      }
+      client.addToolCallsToLastMessage(updatedTools);
+      await client.continueRun(updatedTools);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      setExecutionError(errorMessage);
+      setIsExecuting(false);
+      throw error;
+    }
+  }, [client, mergedHandlers, isPaused, pendingTools]);
+  useEffect2(() => {
+    const handleSessionLoaded = async (_sessionId) => {
+      const messages = client.getMessages();
+      for (const message of messages) {
+        if (!message.tool_calls)
+          continue;
+        for (const tool of message.tool_calls) {
+          if (tool.ui_component)
+            continue;
+          const handler = mergedHandlers[tool.tool_name];
+          if (!handler)
+            continue;
+          try {
+            const result = await handler(tool.tool_args);
+            const { uiComponent } = processToolResult(result, tool);
+            if (uiComponent) {
+              client.hydrateToolCallUI(tool.tool_call_id, uiComponent);
+            }
+          } catch (err) {
+            console.error(`Failed to hydrate UI for ${tool.tool_name}:`, err);
+          }
+        }
+      }
+    };
+    client.on("session:loaded", handleSessionLoaded);
+    return () => {
+      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) => {
+      if (!isPaused) {
+        throw new Error("No paused run to continue");
+      }
+      setIsExecuting(true);
+      try {
+        await client.continueRun(tools);
+      } 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 {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("[GenerativeUIRenderer] Error rendering component:", error, errorInfo);
+    this.props.onError?.(error);
+  }
+  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.children;
+  }
+};
+function GenerativeUIRenderer({
+  spec,
+  className,
+  onError
+}) {
+  const registry = getComponentRegistry();
+  if (spec.type === "custom") {
+    const customSpec = spec;
+    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__ */ 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." })
+    ] });
+  }
+  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) })
+    ] });
+  }
+  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 })
+      ] }) });
+    }
+  }
+  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 })
+      ] }) });
+    }
+  }
+  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__ */ jsx3("div", { className, children: markdownSpec.props.content });
+  }
+  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__ */ 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
+    ] })
+  ] });
+}
+
+// src/utils/ui-helpers.ts
+function createBarChart(data, xKey, bars, options) {
+  return {
+    type: "chart",
+    component: "BarChart",
+    layout: options?.layout,
+    title: options?.title,
+    description: options?.description,
+    props: {
+      data,
+      xKey,
+      bars: bars.map((bar) => ({
+        key: bar.key,
+        label: bar.label || bar.key,
+        color: bar.color
+      })),
+      showLegend: options?.showLegend ?? true,
+      showGrid: options?.showGrid ?? true,
+      height: options?.height,
+      width: options?.width
+    }
+  };
+}
+function createLineChart(data, xKey, lines, options) {
+  return {
+    type: "chart",
+    component: "LineChart",
+    layout: options?.layout,
+    title: options?.title,
+    description: options?.description,
+    props: {
+      data,
+      xKey,
+      lines: lines.map((line) => ({
+        key: line.key,
+        label: line.label || line.key,
+        color: line.color
+      })),
+      showLegend: options?.showLegend ?? true,
+      showGrid: options?.showGrid ?? true,
+      height: options?.height,
+      width: options?.width
+    }
+  };
+}
+function createPieChart(data, dataKey, nameKey, options) {
+  return {
+    type: "chart",
+    component: "PieChart",
+    layout: options?.layout,
+    title: options?.title,
+    description: options?.description,
+    props: {
+      data,
+      pie: {
+        dataKey,
+        nameKey,
+        label: options?.showLabel ?? true
+      },
+      showLegend: options?.showLegend ?? true,
+      height: options?.height || 400,
+      width: options?.width
+    }
+  };
+}
+function createAreaChart(data, xKey, areas, options) {
+  return {
+    type: "chart",
+    component: "AreaChart",
+    layout: options?.layout,
+    title: options?.title,
+    description: options?.description,
+    props: {
+      data,
+      xKey,
+      areas: areas.map((area) => ({
+        key: area.key,
+        label: area.label || area.key,
+        color: area.color
+      })),
+      showLegend: options?.showLegend ?? true,
+      showGrid: options?.showGrid ?? true,
+      height: options?.height,
+      width: options?.width
+    }
+  };
+}
+function createCardGrid(cards, options) {
+  return {
+    type: "card-grid",
+    layout: options?.layout,
+    title: options?.title,
+    description: options?.description,
+    props: {
+      cards,
+      columns: options?.columns || { default: 1, md: 2, lg: 3 },
+      variant: options?.variant || "default"
+    }
+  };
+}
+function createCard(id, title, description, options) {
+  return {
+    id,
+    title,
+    description,
+    image: options?.image,
+    metadata: options?.metadata,
+    actions: options?.actions
+  };
+}
+function createTable(data, columns, options) {
+  return {
+    type: "table",
+    layout: options?.layout,
+    title: options?.title,
+    description: options?.description,
+    props: {
+      data,
+      columns,
+      sortable: options?.sortable ?? true,
+      filterable: options?.filterable,
+      pagination: options?.pagination,
+      density: options?.density || "comfortable"
+    }
+  };
+}
+function createColumn(key, header, options) {
+  return {
+    key,
+    header,
+    width: options?.width,
+    sortable: options?.sortable,
+    cellType: options?.cellType || "text",
+    format: options?.format
+  };
+}
+function createMarkdown(content, options) {
+  return {
+    type: "markdown",
+    layout: options?.layout,
+    title: options?.title,
+    description: options?.description,
+    props: {
+      content,
+      syntaxHighlight: options?.syntaxHighlight ?? true
+    }
+  };
+}
+function createArtifact(content, options) {
+  return {
+    type: "artifact",
+    title: options?.title,
+    description: options?.description,
+    props: {
+      content,
+      variant: options?.variant || "default"
+    }
+  };
+}
+function createSmartChart(data, options) {
+  if (!data || data.length === 0) {
+    return createBarChart([], "", [], 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 numericKeys = keys.filter((k) => k !== xKey && typeof firstItem[k] === "number");
+  const yKeys = options?.yKeys || numericKeys;
+  if ((options?.preferredType === "pie" || yKeys.length === 1) && typeof firstItem[xKey] === "string") {
+    return createPieChart(data, yKeys[0], xKey, options);
+  }
+  if (options?.preferredType === "line" || 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 createBarChart(
+    data,
+    xKey,
+    yKeys.map((key) => ({ key })),
+    options
+  );
+}
+function createToolResult(data, ui) {
+  return { data, ui };
+}
+function resultWithBarChart(data, xKey, bars, options) {
+  return createToolResult(data, createBarChart(data, xKey, bars, options));
+}
+function resultWithSmartChart(data, options) {
+  return createToolResult(data, createSmartChart(data, options));
+}
+function resultWithCardGrid(cards, options) {
+  return createToolResult(cards, createCardGrid(cards, options));
+}
+function resultWithTable(data, columns, options) {
+  return createToolResult(data, createTable(data, columns, options));
+}
+
 // src/hooks/useAgnoChat.ts
-import { useState, useEffect as useEffect2, useCallback } from "react";
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3 } from "react";
 function useAgnoChat() {
   const client = useAgnoClient();
-  const [messages, setMessages] = useState(client.getMessages());
-  const [state, setState] = useState(client.getState());
-  const [error, setError] = useState();
-  useEffect2(() => {
+  const [messages, setMessages] = useState3(client.getMessages());
+  const [state, setState] = useState3(client.getState());
+  const [error, setError] = useState3();
+  useEffect3(() => {
     const handleMessageUpdate = (updatedMessages) => {
-      console.log("[useAgnoChat] message:update event received, messages:", updatedMessages.length);
       setMessages(updatedMessages);
     };
     const handleMessageComplete = (updatedMessages) => {
-      console.log("[useAgnoChat] message:complete event received, messages:", updatedMessages.length);
       setMessages(updatedMessages);
     };
     const handleMessageError = (errorMessage) => {
-      console.log("[useAgnoChat] message:error event received:", errorMessage);
       setError(errorMessage);
     };
     const handleStateChange = (newState) => {
-      console.log("[useAgnoChat] state:change event received");
       setState(newState);
     };
+    const handleUIRender = (event) => {
+      const { tools } = event;
+      for (const tool of tools) {
+        if (tool.ui_component) {
+          client.hydrateToolCallUI(tool.tool_call_id, tool.ui_component);
+        }
+      }
+    };
     client.on("message:update", handleMessageUpdate);
     client.on("message:complete", handleMessageComplete);
     client.on("message:error", handleMessageError);
     client.on("state:change", handleStateChange);
-    console.log("[useAgnoChat] Initializing with messages:", client.getMessages().length);
+    client.on("ui:render", handleUIRender);
     setMessages(client.getMessages());
     setState(client.getState());
     return () => {
@@ -56,9 +708,10 @@ function useAgnoChat() {
       client.off("message:complete", handleMessageComplete);
       client.off("message:error", handleMessageError);
       client.off("state:change", handleStateChange);
+      client.off("ui:render", handleUIRender);
     };
   }, [client]);
-  const sendMessage = useCallback(
+  const sendMessage = useCallback3(
     async (message, options) => {
       setError(void 0);
       try {
@@ -71,7 +724,7 @@ function useAgnoChat() {
     },
     [client]
   );
-  const clearMessages = useCallback(() => {
+  const clearMessages = useCallback3(() => {
     client.clearMessages();
     setMessages([]);
     setError(void 0);
@@ -88,16 +741,16 @@ function useAgnoChat() {
 }
 
 // src/hooks/useAgnoSession.ts
-import { useState as useState2, useEffect as useEffect3, useCallback as useCallback2 } from "react";
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback4 } from "react";
 function useAgnoSession() {
   const client = useAgnoClient();
-  const [sessions, setSessions] = useState2([]);
-  const [currentSessionId, setCurrentSessionId] = useState2(
+  const [sessions, setSessions] = useState4([]);
+  const [currentSessionId, setCurrentSessionId] = useState4(
     client.getConfig().sessionId
   );
-  const [isLoading, setIsLoading] = useState2(false);
-  const [error, setError] = useState2();
-  useEffect3(() => {
+  const [isLoading, setIsLoading] = useState4(false);
+  const [error, setError] = useState4();
+  useEffect4(() => {
     const handleSessionLoaded = (sessionId) => {
       setCurrentSessionId(sessionId);
     };
@@ -121,7 +774,7 @@ function useAgnoSession() {
       client.off("state:change", handleStateChange);
     };
   }, [client]);
-  const loadSession = useCallback2(
+  const loadSession = useCallback4(
     async (sessionId) => {
       setIsLoading(true);
       setError(void 0);
@@ -139,7 +792,7 @@ function useAgnoSession() {
     },
     [client]
   );
-  const fetchSessions = useCallback2(async () => {
+  const fetchSessions = useCallback4(async () => {
     setIsLoading(true);
     setError(void 0);
     try {
@@ -165,12 +818,12 @@ function useAgnoSession() {
 }
 
 // src/hooks/useAgnoActions.ts
-import { useState as useState3, useCallback as useCallback3 } from "react";
+import { useState as useState5, useCallback as useCallback5 } from "react";
 function useAgnoActions() {
   const client = useAgnoClient();
-  const [isInitializing, setIsInitializing] = useState3(false);
-  const [error, setError] = useState3();
-  const initialize = useCallback3(async () => {
+  const [isInitializing, setIsInitializing] = useState5(false);
+  const [error, setError] = useState5();
+  const initialize = useCallback5(async () => {
     setIsInitializing(true);
     setError(void 0);
     try {
@@ -184,7 +837,7 @@ function useAgnoActions() {
       setIsInitializing(false);
     }
   }, [client]);
-  const checkStatus = useCallback3(async () => {
+  const checkStatus = useCallback5(async () => {
     setError(void 0);
     try {
       return await client.checkStatus();
@@ -194,7 +847,7 @@ function useAgnoActions() {
       return false;
     }
   }, [client]);
-  const fetchAgents = useCallback3(async () => {
+  const fetchAgents = useCallback5(async () => {
     setError(void 0);
     try {
       return await client.fetchAgents();
@@ -204,7 +857,7 @@ function useAgnoActions() {
       throw err;
     }
   }, [client]);
-  const fetchTeams = useCallback3(async () => {
+  const fetchTeams = useCallback5(async () => {
     setError(void 0);
     try {
       return await client.fetchTeams();
@@ -214,7 +867,7 @@ function useAgnoActions() {
       throw err;
     }
   }, [client]);
-  const updateConfig = useCallback3(
+  const updateConfig = useCallback5(
     (updates) => {
       client.updateConfig(updates);
     },
@@ -230,155 +883,35 @@ function useAgnoActions() {
     error
   };
 }
-
-// src/hooks/useAgnoToolExecution.ts
-import { useState as useState4, useEffect as useEffect4, useCallback as useCallback4 } from "react";
-function useAgnoToolExecution(handlers, autoExecute = true) {
-  const client = useAgnoClient();
-  const [pendingTools, setPendingTools] = useState4([]);
-  const [isPaused, setIsPaused] = useState4(false);
-  const [isExecuting, setIsExecuting] = useState4(false);
-  const [executionError, setExecutionError] = useState4();
-  useEffect4(() => {
-    const handleRunPaused = (event) => {
-      console.log("[useAgnoToolExecution] Run paused, tools:", event.tools);
-      setIsPaused(true);
-      setPendingTools(event.tools);
-      setExecutionError(void 0);
-    };
-    const handleRunContinued = () => {
-      console.log("[useAgnoToolExecution] Run continued");
-      setIsPaused(false);
-      setPendingTools([]);
-      setIsExecuting(false);
-      setExecutionError(void 0);
-    };
-    client.on("run:paused", handleRunPaused);
-    client.on("run:continued", handleRunContinued);
-    return () => {
-      client.off("run:paused", handleRunPaused);
-      client.off("run:continued", handleRunContinued);
-    };
-  }, [client]);
-  const executeAndContinue = useCallback4(async () => {
-    if (!isPaused || pendingTools.length === 0) {
-      console.warn("[useAgnoToolExecution] Cannot execute: no pending tools");
-      return;
-    }
-    setIsExecuting(true);
-    setExecutionError(void 0);
-    try {
-      console.log("[useAgnoToolExecution] Executing", pendingTools.length, "tools");
-      const updatedTools = await Promise.all(
-        pendingTools.map(async (tool) => {
-          const handler = handlers[tool.tool_name];
-          if (!handler) {
-            console.warn(`[useAgnoToolExecution] No handler for tool: ${tool.tool_name}`);
-            return {
-              ...tool,
-              result: JSON.stringify({
-                error: `No handler registered for ${tool.tool_name}`
-              })
-            };
-          }
-          try {
-            console.log(`[useAgnoToolExecution] Executing tool: ${tool.tool_name}`, tool.tool_args);
-            const result = await handler(tool.tool_args);
-            console.log(`[useAgnoToolExecution] Tool result:`, result);
-            return {
-              ...tool,
-              result: typeof result === "string" ? result : JSON.stringify(result)
-            };
-          } catch (error) {
-            console.error(`[useAgnoToolExecution] Tool execution error:`, error);
-            return {
-              ...tool,
-              result: JSON.stringify({
-                error: error instanceof Error ? error.message : String(error)
-              })
-            };
-          }
-        })
-      );
-      console.log("[useAgnoToolExecution] Continuing run with results");
-      await client.continueRun(updatedTools);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[useAgnoToolExecution] Failed to continue run:", errorMessage);
-      setExecutionError(errorMessage);
-      setIsExecuting(false);
-      throw error;
-    }
-  }, [client, handlers, isPaused, pendingTools]);
-  const executeTools = useCallback4(
-    async (tools) => {
-      return Promise.all(
-        tools.map(async (tool) => {
-          const handler = handlers[tool.tool_name];
-          if (!handler)
-            return tool;
-          try {
-            const result = await handler(tool.tool_args);
-            return {
-              ...tool,
-              result: typeof result === "string" ? result : JSON.stringify(result)
-            };
-          } catch (error) {
-            return {
-              ...tool,
-              result: JSON.stringify({
-                error: error instanceof Error ? error.message : String(error)
-              })
-            };
-          }
-        })
-      );
-    },
-    [handlers]
-  );
-  const continueWithResults = useCallback4(
-    async (tools) => {
-      if (!isPaused) {
-        throw new Error("No paused run to continue");
-      }
-      setIsExecuting(true);
-      try {
-        await client.continueRun(tools);
-      } catch (error) {
-        setIsExecuting(false);
-        throw error;
-      }
-    },
-    [client, isPaused]
-  );
-  useEffect4(() => {
-    if (autoExecute && isPaused && !isExecuting && pendingTools.length > 0) {
-      console.log("[useAgnoToolExecution] Auto-executing tools");
-      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
-  };
-}
 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,
   useAgnoSession,
-  useAgnoToolExecution
+  useAgnoToolExecution,
+  useToolHandlers
 };