@antipopp/agno-react 0.1.0

package/dist/index.js

@@ -0,0 +1,416 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AgnoProvider: () => AgnoProvider,
+  useAgnoActions: () => useAgnoActions,
+  useAgnoChat: () => useAgnoChat,
+  useAgnoClient: () => useAgnoClient,
+  useAgnoSession: () => useAgnoSession,
+  useAgnoToolExecution: () => useAgnoToolExecution
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/context/AgnoContext.tsx
+var import_react = require("react");
+var import_agno_client = require("@antipopp/agno-client");
+var import_jsx_runtime = require("react/jsx-runtime");
+var AgnoContext = (0, import_react.createContext)(null);
+function AgnoProvider({ config, children }) {
+  const client = (0, import_react.useMemo)(() => new import_agno_client.AgnoClient(config), []);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      client.removeAllListeners();
+    };
+  }, [client]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AgnoContext.Provider, { value: client, children });
+}
+function useAgnoClient() {
+  const client = (0, import_react.useContext)(AgnoContext);
+  if (!client) {
+    throw new Error("useAgnoClient must be used within an AgnoProvider");
+  }
+  return client;
+}
+
+// src/hooks/useAgnoChat.ts
+var import_react2 = require("react");
+function useAgnoChat() {
+  const client = useAgnoClient();
+  const [messages, setMessages] = (0, import_react2.useState)(client.getMessages());
+  const [state, setState] = (0, import_react2.useState)(client.getState());
+  const [error, setError] = (0, import_react2.useState)();
+  (0, import_react2.useEffect)(() => {
+    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);
+    };
+    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);
+    setMessages(client.getMessages());
+    setState(client.getState());
+    return () => {
+      client.off("message:update", handleMessageUpdate);
+      client.off("message:complete", handleMessageComplete);
+      client.off("message:error", handleMessageError);
+      client.off("state:change", handleStateChange);
+    };
+  }, [client]);
+  const sendMessage = (0, import_react2.useCallback)(
+    async (message, options) => {
+      setError(void 0);
+      try {
+        await client.sendMessage(message, options);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        setError(errorMessage);
+        throw err;
+      }
+    },
+    [client]
+  );
+  const clearMessages = (0, import_react2.useCallback)(() => {
+    client.clearMessages();
+    setMessages([]);
+    setError(void 0);
+  }, [client]);
+  return {
+    messages,
+    sendMessage,
+    clearMessages,
+    isStreaming: state.isStreaming,
+    isPaused: state.isPaused,
+    error,
+    state
+  };
+}
+
+// src/hooks/useAgnoSession.ts
+var import_react3 = require("react");
+function useAgnoSession() {
+  const client = useAgnoClient();
+  const [sessions, setSessions] = (0, import_react3.useState)([]);
+  const [currentSessionId, setCurrentSessionId] = (0, import_react3.useState)(
+    client.getConfig().sessionId
+  );
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)();
+  (0, import_react3.useEffect)(() => {
+    const handleSessionLoaded = (sessionId) => {
+      setCurrentSessionId(sessionId);
+    };
+    const handleSessionCreated = (session) => {
+      setSessions((prev) => [session, ...prev]);
+      setCurrentSessionId(session.session_id);
+    };
+    const handleStateChange = () => {
+      const config = client.getConfig();
+      setCurrentSessionId(config.sessionId);
+      setSessions(client.getState().sessions);
+    };
+    client.on("session:loaded", handleSessionLoaded);
+    client.on("session:created", handleSessionCreated);
+    client.on("state:change", handleStateChange);
+    setSessions(client.getState().sessions);
+    setCurrentSessionId(client.getConfig().sessionId);
+    return () => {
+      client.off("session:loaded", handleSessionLoaded);
+      client.off("session:created", handleSessionCreated);
+      client.off("state:change", handleStateChange);
+    };
+  }, [client]);
+  const loadSession = (0, import_react3.useCallback)(
+    async (sessionId) => {
+      setIsLoading(true);
+      setError(void 0);
+      try {
+        const messages = await client.loadSession(sessionId);
+        setCurrentSessionId(sessionId);
+        return messages;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        setError(errorMessage);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client]
+  );
+  const fetchSessions = (0, import_react3.useCallback)(async () => {
+    setIsLoading(true);
+    setError(void 0);
+    try {
+      const fetchedSessions = await client.fetchSessions();
+      setSessions(fetchedSessions);
+      return fetchedSessions;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  return {
+    sessions,
+    currentSessionId,
+    loadSession,
+    fetchSessions,
+    isLoading,
+    error
+  };
+}
+
+// src/hooks/useAgnoActions.ts
+var import_react4 = require("react");
+function useAgnoActions() {
+  const client = useAgnoClient();
+  const [isInitializing, setIsInitializing] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)();
+  const initialize = (0, import_react4.useCallback)(async () => {
+    setIsInitializing(true);
+    setError(void 0);
+    try {
+      const result = await client.initialize();
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsInitializing(false);
+    }
+  }, [client]);
+  const checkStatus = (0, import_react4.useCallback)(async () => {
+    setError(void 0);
+    try {
+      return await client.checkStatus();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      return false;
+    }
+  }, [client]);
+  const fetchAgents = (0, import_react4.useCallback)(async () => {
+    setError(void 0);
+    try {
+      return await client.fetchAgents();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    }
+  }, [client]);
+  const fetchTeams = (0, import_react4.useCallback)(async () => {
+    setError(void 0);
+    try {
+      return await client.fetchTeams();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setError(errorMessage);
+      throw err;
+    }
+  }, [client]);
+  const updateConfig = (0, import_react4.useCallback)(
+    (updates) => {
+      client.updateConfig(updates);
+    },
+    [client]
+  );
+  return {
+    initialize,
+    checkStatus,
+    fetchAgents,
+    fetchTeams,
+    updateConfig,
+    isInitializing,
+    error
+  };
+}
+
+// src/hooks/useAgnoToolExecution.ts
+var import_react5 = require("react");
+function useAgnoToolExecution(handlers, autoExecute = true) {
+  const client = useAgnoClient();
+  const [pendingTools, setPendingTools] = (0, import_react5.useState)([]);
+  const [isPaused, setIsPaused] = (0, import_react5.useState)(false);
+  const [isExecuting, setIsExecuting] = (0, import_react5.useState)(false);
+  const [executionError, setExecutionError] = (0, import_react5.useState)();
+  (0, import_react5.useEffect)(() => {
+    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 = (0, import_react5.useCallback)(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 = (0, import_react5.useCallback)(
+    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 = (0, import_react5.useCallback)(
+    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]
+  );
+  (0, import_react5.useEffect)(() => {
+    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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgnoProvider,
+  useAgnoActions,
+  useAgnoChat,
+  useAgnoClient,
+  useAgnoSession,
+  useAgnoToolExecution
+});