griptape-nodes 0.36.2__py3-none-any.whl → 0.37.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -0,0 +1,103 @@
+import logging
+
+from griptape.artifacts import ErrorArtifact
+from griptape.drivers.prompt.griptape_cloud import GriptapeCloudPromptDriver
+from griptape.memory.structure import ConversationMemory
+from griptape.tasks import PromptTask
+
+from griptape_nodes.retained_mode.events.agent_events import (
+    ConfigureAgentRequest,
+    ConfigureAgentResultFailure,
+    ConfigureAgentResultSuccess,
+    GetConversationMemoryRequest,
+    GetConversationMemoryResultFailure,
+    GetConversationMemoryResultSuccess,
+    ResetAgentConversationMemoryRequest,
+    ResetAgentConversationMemoryResultFailure,
+    ResetAgentConversationMemoryResultSuccess,
+    RunAgentRequest,
+    RunAgentResultFailure,
+    RunAgentResultSuccess,
+)
+from griptape_nodes.retained_mode.events.base_events import ResultPayload
+from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
+from griptape_nodes.retained_mode.managers.event_manager import EventManager
+from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
+
+logger = logging.getLogger("griptape_nodes")
+
+API_KEY_ENV_VAR = "GT_CLOUD_API_KEY"
+SERVICE = "Griptape"
+
+config_manager = ConfigManager()
+secrets_manager = SecretsManager(config_manager)
+
+
+class AgentManager:
+    def __init__(self, event_manager: EventManager | None = None) -> None:
+        self.conversation_memory = ConversationMemory()
+        self.prompt_driver = None
+
+        if event_manager is not None:
+            event_manager.assign_manager_to_request_type(RunAgentRequest, self.on_handle_run_agent_request)
+            event_manager.assign_manager_to_request_type(ConfigureAgentRequest, self.on_handle_configure_agent_request)
+            event_manager.assign_manager_to_request_type(
+                ResetAgentConversationMemoryRequest, self.on_handle_reset_agent_conversation_memory_request
+            )
+            event_manager.assign_manager_to_request_type(
+                GetConversationMemoryRequest, self.on_handle_get_conversation_memory_request
+            )
+
+    def _initialize_prompt_driver(self) -> GriptapeCloudPromptDriver:
+        api_key = secrets_manager.get_secret(API_KEY_ENV_VAR)
+        if not api_key:
+            msg = f"Secret '{API_KEY_ENV_VAR}' not found"
+            raise ValueError(msg)
+        return GriptapeCloudPromptDriver(api_key=api_key)
+
+    def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
+        try:
+            if self.prompt_driver is None:
+                self.prompt_driver = self._initialize_prompt_driver()
+            task_output = PromptTask(
+                request.input, prompt_driver=self.prompt_driver, conversation_memory=self.conversation_memory
+            ).run()
+            if isinstance(task_output, ErrorArtifact):
+                details = f"Error running agent: {task_output.value}"
+                logger.error(details)
+                return RunAgentResultFailure(error=task_output.to_json())
+            return RunAgentResultSuccess(output=task_output.to_json())
+        except Exception as e:
+            return RunAgentResultFailure(ErrorArtifact(e).to_json())
+
+    def on_handle_configure_agent_request(self, request: ConfigureAgentRequest) -> ResultPayload:
+        try:
+            if self.prompt_driver is None:
+                self.prompt_driver = self._initialize_prompt_driver()
+            for key, value in request.prompt_driver.items():
+                setattr(self.prompt_driver, key, value)
+        except Exception as e:
+            details = f"Error configuring agent: {e}"
+            logger.error(details)
+            return ConfigureAgentResultFailure()
+        return ConfigureAgentResultSuccess()
+
+    def on_handle_reset_agent_conversation_memory_request(
+        self, _: ResetAgentConversationMemoryRequest
+    ) -> ResultPayload:
+        try:
+            self.conversation_memory = ConversationMemory()
+        except Exception as e:
+            details = f"Error resetting agent conversation memory: {e}"
+            logger.error(details)
+            return ResetAgentConversationMemoryResultFailure()
+        return ResetAgentConversationMemoryResultSuccess()
+
+    def on_handle_get_conversation_memory_request(self, _: GetConversationMemoryRequest) -> ResultPayload:
+        try:
+            conversation_memory = self.conversation_memory.runs
+        except Exception as e:
+            details = f"Error getting conversation memory: {e}"
+            logger.error(details)
+            return GetConversationMemoryResultFailure()
+        return GetConversationMemoryResultSuccess(runs=conversation_memory)

griptape_nodes/retained_mode/managers/library_manager.py

@@ -456,37 +456,14 @@ class LibraryManager:
 
         # Install node library dependencies
         try:
-            site_packages = None
             if library_data.metadata.dependencies and library_data.metadata.dependencies.pip_dependencies:
                 pip_install_flags = library_data.metadata.dependencies.pip_install_flags
                 if pip_install_flags is None:
                     pip_install_flags = []
                 pip_dependencies = library_data.metadata.dependencies.pip_dependencies
 
-                # Create a virtual environment for the library
-                python_version = platform.python_version()
-                library_venv_path = (
-                    xdg_data_home()
-                    / "griptape_nodes"
-                    / "venvs"
-                    / python_version
-                    / library_data.name.replace(" ", "_").strip()
-                )
-                if library_venv_path.exists():
-                    logger.debug("Virtual environment already exists at %s", library_venv_path)
-                else:
-                    subprocess.run(  # noqa: S603
-                        [sys.executable, "-m", "uv", "venv", library_venv_path, "--python", python_version],
-                        check=True,
-                        text=True,
-                    )
-                    logger.debug("Created virtual environment at %s", library_venv_path)
-
                 # Grab the python executable from the virtual environment so that we can pip install there
-                if OSManager.is_windows():
-                    library_venv_python_path = library_venv_path / "Scripts" / "python.exe"
-                else:
-                    library_venv_python_path = library_venv_path / "bin" / "python"
+                library_venv_python_path = self._get_library_venv_python_path(library_data.name)
                 subprocess.run(  # noqa: S603
                     [
                         sys.executable,
@@ -502,16 +479,6 @@ class LibraryManager:
                     check=True,
                     text=True,
                 )
-                # Need to insert into the path so that the library picks up on the venv
-                site_packages = str(
-                    Path(
-                        sysconfig.get_path(
-                            "purelib",
-                            vars={"base": str(library_venv_path), "platbase": str(library_venv_path)},
-                        )
-                    )
-                )
-                sys.path.insert(0, site_packages)
         except subprocess.CalledProcessError as e:
             # Failed to create the library
             self._library_file_path_to_info[file_path] = LibraryManager.LibraryInfo(
@@ -595,15 +562,26 @@ class LibraryManager:
     def register_library_from_requirement_specifier_request(
         self, request: RegisterLibraryFromRequirementSpecifierRequest
     ) -> ResultPayload:
+        package_name = Requirement(request.requirement_specifier).name
         try:
-            subprocess.run([uv.find_uv_bin(), "pip", "install", request.requirement_specifier], check=True, text=True)  # noqa: S603
+            library_python_venv_path = self._get_library_venv_python_path(package_name)
+            subprocess.run(  # noqa: S603
+                [
+                    uv.find_uv_bin(),
+                    "pip",
+                    "install",
+                    request.requirement_specifier,
+                    "--python",
+                    library_python_venv_path,
+                ],
+                check=True,
+                text=True,
+            )
         except subprocess.CalledProcessError as e:
             details = f"Attempted to install library '{request.requirement_specifier}'. Failed due to {e}"
             logger.error(details)
             return RegisterLibraryFromRequirementSpecifierResultFailure()
 
-        package_name = Requirement(request.requirement_specifier).name
-
         library_path = str(files(package_name).joinpath(request.library_config_name))
 
         register_result = GriptapeNodes.handle_request(RegisterLibraryFromFileRequest(file_path=library_path))
@@ -614,6 +592,41 @@ class LibraryManager:
 
         return RegisterLibraryFromRequirementSpecifierResultSuccess(library_name=request.requirement_specifier)
 
+    def _get_library_venv_python_path(self, library_name: str) -> Path:
+        # Create a virtual environment for the library
+        python_version = platform.python_version()
+        library_venv_path = (
+            xdg_data_home() / "griptape_nodes" / "venvs" / python_version / library_name.replace(" ", "_").strip()
+        )
+        if library_venv_path.exists():
+            logger.debug("Virtual environment already exists at %s", library_venv_path)
+        else:
+            subprocess.run(  # noqa: S603
+                [sys.executable, "-m", "uv", "venv", str(library_venv_path), "--python", python_version],
+                check=True,
+                text=True,
+            )
+            logger.debug("Created virtual environment at %s", library_venv_path)
+
+        # Grab the python executable from the virtual environment so that we can pip install there
+        if OSManager.is_windows():
+            library_venv_python_path = library_venv_path / "Scripts" / "python.exe"
+        else:
+            library_venv_python_path = library_venv_path / "bin" / "python"
+
+        # Need to insert into the path so that the library picks up on the venv
+        site_packages = str(
+            Path(
+                sysconfig.get_path(
+                    "purelib",
+                    vars={"base": str(library_venv_path), "platbase": str(library_venv_path)},
+                )
+            )
+        )
+        sys.path.insert(0, site_packages)
+
+        return library_venv_python_path
+
     def unload_library_from_registry_request(self, request: UnloadLibraryFromRegistryRequest) -> ResultPayload:
         try:
             LibraryRegistry.unregister_library(library_name=request.library_name)

griptape_nodes/retained_mode/managers/node_manager.py

@@ -14,7 +14,7 @@ from griptape_nodes.exe_types.core_types import (
     ParameterTypeBuiltin,
 )
 from griptape_nodes.exe_types.flow import ControlFlow
-from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
+from griptape_nodes.exe_types.node_types import BaseNode, EndLoopNode, NodeResolutionState, StartLoopNode
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.node_library.library_registry import LibraryNameAndVersion, LibraryRegistry
 from griptape_nodes.retained_mode.events.base_events import (
@@ -284,7 +284,6 @@ class NodeManager:
             details = f"Could not create Node '{final_node_name}' of type '{request.node_type}': {err}"
             logger.error(details)
             return CreateNodeResultFailure()
-
         # Add it to the Flow.
         parent_flow.add_node(node)
 
@@ -320,6 +319,33 @@ class NodeManager:
 
         logger.log(level=log_level, msg=details)
 
+        if isinstance(node, StartLoopNode) and not request.initial_setup:
+            # If it's StartLoop, create an EndLoop and connect it to the StartLoop.
+            end_loop = GriptapeNodes.handle_request(
+                CreateNodeRequest(
+                    node_type="ForEachEndNode",
+                    metadata={
+                        "position": {"x": node.metadata["position"]["x"] + 650, "y": node.metadata["position"]["y"]}
+                    },
+                    override_parent_flow_name=parent_flow_name,
+                )
+            )
+            if isinstance(end_loop, CreateNodeResultSuccess):
+                # Create Loop between output and input to the start node.
+                GriptapeNodes.handle_request(
+                    CreateConnectionRequest(
+                        source_node_name=node.name,
+                        source_parameter_name="loop",
+                        target_node_name=end_loop.node_name,
+                        target_parameter_name="from_start",
+                    )
+                )
+                end_node = self.get_node_by_name(end_loop.node_name)
+                if isinstance(end_node, EndLoopNode):
+                    # create the connection bt them
+                    node.end_node = end_node
+                    end_node.start_node = node
+
         return CreateNodeResultSuccess(
             node_name=node.name, node_type=node.__class__.__name__, specific_library_name=request.specific_library_name
         )
@@ -1723,6 +1749,7 @@ class NodeManager:
                 metadata=copy.deepcopy(node.metadata),
                 # If it is actively resolving, mark as unresolved.
                 resolution=node.state.value,
+                initial_setup=True,
             )
 
             # We're going to compare this node instance vs. a canonical one. Rez that one up.