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

griptape_nodes/__init__.py

@@ -15,7 +15,7 @@ with console.status("Loading Griptape Nodes...") as status:
     import tarfile
     import tempfile
     from pathlib import Path
-    from typing import Literal
+    from typing import Any, Literal
 
     import httpx
     from dotenv import load_dotenv
@@ -75,7 +75,7 @@ def main() -> None:
     _process_args(args)
 
 
-def _run_init(  # noqa: PLR0913
+def _run_init(  # noqa: PLR0913, C901
     *,
     interactive: bool = True,
     workspace_directory: str | None = None,
@@ -83,6 +83,8 @@ def _run_init(  # noqa: PLR0913
     storage_backend: str | None = None,
     storage_backend_bucket_id: str | None = None,
     register_advanced_library: bool | None = None,
+    config_values: dict[str, Any] | None = None,
+    secret_values: dict[str, str] | None = None,
 ) -> None:
     """Runs through the engine init steps.
 
@@ -93,6 +95,8 @@ def _run_init(  # noqa: PLR0913
         storage_backend (str | None): The storage backend to set.
         storage_backend_bucket_id (str | None): The storage backend bucket ID to set.
         register_advanced_library (bool | None): Whether to register the advanced library.
+        config_values (dict[str, any] | None): Arbitrary config key-value pairs to set.
+        secret_values (dict[str, str] | None): Arbitrary secret key-value pairs to set.
     """
     __init_system_config()
 
@@ -132,6 +136,18 @@ def _run_init(  # noqa: PLR0913
         )
         console.print(f"[bold green]Libraries to register set to: {', '.join(libraries_to_register)}[/bold green]")
 
+    # Set arbitrary config values
+    if config_values:
+        for key, value in config_values.items():
+            config_manager.set_config_value(key, value)
+            console.print(f"[bold green]Config '{key}' set to: {value}[/bold green]")
+
+    # Set arbitrary secret values
+    if secret_values:
+        for key, value in secret_values.items():
+            secrets_manager.set_secret(key, value)
+            console.print(f"[bold green]Secret '{key}' set[/bold green]")
+
     _sync_assets()
     console.print("[bold green]Initialization complete![/bold green]")
 
@@ -152,6 +168,8 @@ def _start_engine(*, no_update: bool = False) -> None:
             storage_backend_bucket_id=ENV_STORAGE_BACKEND_BUCKET_ID,
             register_advanced_library=ENV_REGISTER_ADVANCED_LIBRARY,
             interactive=True,
+            config_values=None,
+            secret_values=None,
         )
 
     # Confusing double negation -- If `no_update` is set, we want to skip the update
@@ -214,6 +232,18 @@ def _get_args() -> argparse.Namespace:
         action="store_true",
         help="Run init in non-interactive mode (no prompts).",
     )
+    init_parser.add_argument(
+        "--config",
+        action="append",
+        metavar="KEY=VALUE",
+        help="Set arbitrary config values as key=value pairs (can be used multiple times). Example: --config log_level=DEBUG --config workspace_directory=/tmp",
+    )
+    init_parser.add_argument(
+        "--secret",
+        action="append",
+        metavar="KEY=VALUE",
+        help="Set arbitrary secret values as key=value pairs (can be used multiple times). Example: --secret MY_API_KEY=abc123 --secret OTHER_KEY=xyz789",
+    )
 
     # engine
     subparsers.add_parser("engine", help="Run the Griptape Nodes engine.")
@@ -430,9 +460,7 @@ def __build_libraries_list(*, register_advanced_library: bool) -> list[str]:
     if default_library not in current_libraries:
         current_libraries.append(default_library)
 
-    advanced_media_library = str(
-        library_base_dir / "griptape_nodes_advanced_media_library/griptape_nodes_advanced_media_library.json"
-    )
+    advanced_media_library = str(library_base_dir / "griptape_nodes_advanced_media_library/griptape_nodes_library.json")
     if register_advanced_library:
         # If the advanced media library is not registered, add it
         if advanced_media_library not in current_libraries:
@@ -637,8 +665,42 @@ def _uninstall_self() -> None:
     os_manager.replace_process(["uv", "tool", "uninstall", "griptape-nodes"])
 
 
+def _parse_key_value_pairs(pairs: list[str] | None) -> dict[str, str] | None:
+    """Parse key=value pairs from a list of strings.
+
+    Args:
+        pairs: List of strings in the format "key=value"
+
+    Returns:
+        Dictionary of key-value pairs, or None if no pairs provided
+    """
+    if not pairs:
+        return None
+
+    result = {}
+    for pair in pairs:
+        if "=" not in pair:
+            console.print(f"[bold red]Invalid key=value pair: {pair}. Expected format: key=value[/bold red]")
+            continue
+        # Split only on the first = to handle values that contain =
+        key, value = pair.split("=", 1)
+        key = key.strip()
+        value = value.strip()
+
+        if not key:
+            console.print(f"[bold red]Empty key in pair: {pair}[/bold red]")
+            continue
+
+        result[key] = value
+
+    return result if result else None
+
+
 def _process_args(args: argparse.Namespace) -> None:  # noqa: C901, PLR0912
     if args.command == "init":
+        config_values = _parse_key_value_pairs(getattr(args, "config", None))
+        secret_values = _parse_key_value_pairs(getattr(args, "secret", None))
+
         _run_init(
             interactive=not args.no_interactive,
             workspace_directory=args.workspace_directory,
@@ -646,6 +708,8 @@ def _process_args(args: argparse.Namespace) -> None:  # noqa: C901, PLR0912
             storage_backend=args.storage_backend,
             storage_backend_bucket_id=args.storage_backend_bucket_id,
             register_advanced_library=args.register_advanced_library,
+            config_values=config_values,
+            secret_values=secret_values,
         )
     elif args.command == "engine":
         _start_engine(no_update=args.no_update)

griptape_nodes/app/__init__.py

@@ -2,7 +2,7 @@
 
 import os
 
-if os.getenv("GTN_USE_WEBSOCKETS", "false").lower() == "true":
+if os.getenv("GTN_USE_WEBSOCKETS", "true").lower() == "true":
     from griptape_nodes.app.app_websocket import start_app
 else:
     from griptape_nodes.app.app import start_app

griptape_nodes/app/app.py

@@ -76,12 +76,6 @@ class EventLogHandler(logging.Handler):
         )
 
 
-griptape_nodes_logger = logging.getLogger("griptape_nodes")
-# When running as an app, we want to forward all log messages to the event queue so they can be sent to the GUI
-griptape_nodes_logger.addHandler(EventLogHandler())
-griptape_nodes_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
-griptape_nodes_logger.setLevel(logging.INFO)
-
 # Logger for this module. Important that this is not the same as the griptape_nodes logger or else we'll have infinite log events.
 logger = logging.getLogger(__name__)
 console = Console()
@@ -94,6 +88,12 @@ def start_app() -> None:
     """
     global socket_manager  # noqa: PLW0603 # Need to initialize the socket lazily here to avoid auth-ing too early
 
+    griptape_nodes_logger = logging.getLogger("griptape_nodes")
+    # When running as an app, we want to forward all log messages to the event queue so they can be sent to the GUI
+    griptape_nodes_logger.addHandler(EventLogHandler())
+    griptape_nodes_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
+    griptape_nodes_logger.setLevel(logging.INFO)
+
     # Listen for SSE events from the Nodes API in a separate thread
     socket_manager = NodesApiSocketManager()
 

griptape_nodes/app/app_websocket.py

@@ -79,12 +79,6 @@ class EventLogHandler(logging.Handler):
         )
 
 
-griptape_nodes_logger = logging.getLogger("griptape_nodes")
-# When running as an app, we want to forward all log messages to the event queue so they can be sent to the GUI
-griptape_nodes_logger.addHandler(EventLogHandler())
-griptape_nodes_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
-griptape_nodes_logger.setLevel(logging.INFO)
-
 # Logger for this module. Important that this is not the same as the griptape_nodes logger or else we'll have infinite log events.
 logger = logging.getLogger("griptape_nodes_app")
 console = Console()
@@ -97,6 +91,12 @@ def start_app() -> None:
     """
     _init_event_listeners()
 
+    griptape_nodes_logger = logging.getLogger("griptape_nodes")
+    # When running as an app, we want to forward all log messages to the event queue so they can be sent to the GUI
+    griptape_nodes_logger.addHandler(EventLogHandler())
+    griptape_nodes_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
+    griptape_nodes_logger.setLevel(logging.INFO)
+
     # Listen for any signals to exit the app
     for sig in (signal.SIGINT, signal.SIGTERM):
         signal.signal(sig, lambda *_: sys.exit(0))

griptape_nodes/exe_types/connections.py

@@ -2,7 +2,7 @@ import logging
 from dataclasses import dataclass
 
 from griptape_nodes.exe_types.core_types import Parameter, ParameterMode, ParameterTypeBuiltin
-from griptape_nodes.exe_types.node_types import BaseNode, Connection, NodeResolutionState
+from griptape_nodes.exe_types.node_types import BaseNode, Connection, EndLoopNode, NodeResolutionState, StartLoopNode
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -99,8 +99,39 @@ class Connections:
         )
         return connection is None
 
+    def _get_connected_node_for_end_loop_control(
+        self, end_loop_node: EndLoopNode, control_parameter: Parameter
+    ) -> tuple[BaseNode, Parameter] | None:
+        """For an EndLoopNode and its control parameter, finds the connected node and parameter.
+
+        It checks both outgoing connections (where EndLoopNode's parameter is a source)
+        and incoming connections (where EndLoopNode's parameter is a target).
+        """
+        # Check if the EndLoopNode's control parameter is a source for an outgoing connection
+        if ParameterMode.OUTPUT in control_parameter.allowed_modes:
+            outgoing_connections_for_node = self.outgoing_index.get(end_loop_node.name, {})
+            connection_ids_as_source = outgoing_connections_for_node.get(control_parameter.name, [])
+            if connection_ids_as_source:
+                connection_id = connection_ids_as_source[0]
+                connection = self.connections.get(connection_id)
+                if connection:
+                    return connection.target_node, connection.target_parameter
+        elif ParameterMode.INPUT in control_parameter.allowed_modes:
+            # Check if the EndLoopNode's control parameter is a target for an incoming connection
+            incoming_connections_for_node = self.incoming_index.get(end_loop_node.name, {})
+            connection_ids_as_target = incoming_connections_for_node.get(control_parameter.name, [])
+            if connection_ids_as_target:
+                for connection_id in connection_ids_as_target:
+                    connection = self.connections.get(connection_id)
+                    if connection and isinstance(connection.source_node, StartLoopNode):
+                        return connection.source_node, connection.source_parameter
+        return None  # No connection found for this control parameter
+
     def get_connected_node(self, node: BaseNode, parameter: Parameter) -> tuple[BaseNode, Parameter] | None:
         # Check to see if we should be getting the next connection or the previous connection based on the parameter.
+        # Override this method for EndLoopNodes - these might have to go backwards or forwards.
+        if isinstance(node, EndLoopNode) and ParameterTypeBuiltin.CONTROL_TYPE.value == parameter.output_type:
+            return self._get_connected_node_for_end_loop_control(node, parameter)
         if ParameterTypeBuiltin.CONTROL_TYPE.value == parameter.output_type:
             connections = self.outgoing_index
         else:

griptape_nodes/exe_types/core_types.py

@@ -163,6 +163,7 @@ class BaseNodeElement:
     element_id: str = field(default_factory=lambda: str(uuid.uuid4().hex))
     element_type: str = field(default_factory=lambda: BaseNodeElement.__name__)
     name: str = field(default_factory=lambda: str(f"{BaseNodeElement.__name__}_{uuid.uuid4().hex}"))
+    parent_group_name: str | None = None
 
     _children: list[BaseNodeElement] = field(default_factory=list)
     _stack: ClassVar[list[BaseNodeElement]] = []
@@ -219,6 +220,7 @@ class BaseNodeElement:
         return {
             "element_id": self.element_id,
             "element_type": self.__class__.__name__,
+            "parent_group_name": self.parent_group_name,
             "children": [child.to_dict() for child in self._children],
         }
 
@@ -409,6 +411,20 @@ class ParameterGroup(BaseNodeElement):
                 differences[key] = other_value
         return differences
 
+    def add_child(self, child: BaseNodeElement) -> None:
+        child.parent_group_name = self.name
+        return super().add_child(child)
+
+    def remove_child(self, child: BaseNodeElement | str) -> None:
+        if isinstance(child, str):
+            child_from_str = self.find_element_by_name(child)
+            if child_from_str is not None and isinstance(child_from_str, BaseNodeElement):
+                child_from_str.parent_group_name = None
+                return super().remove_child(child_from_str)
+        else:
+            child.parent_group_name = None
+        return super().remove_child(child)
+
 
 # TODO: https://github.com/griptape-ai/griptape-nodes/issues/856
 class ParameterBase(BaseNodeElement, ABC):

griptape_nodes/exe_types/flow.py

@@ -8,7 +8,7 @@ from griptape.events import EventBus
 
 from griptape_nodes.exe_types.connections import Connections
 from griptape_nodes.exe_types.core_types import ParameterTypeBuiltin
-from griptape_nodes.exe_types.node_types import NodeResolutionState, StartNode
+from griptape_nodes.exe_types.node_types import NodeResolutionState, StartLoopNode, StartNode
 from griptape_nodes.machines.control_flow import CompleteState, ControlFlowMachine
 from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent
 from griptape_nodes.retained_mode.events.execution_events import ControlFlowCancelledEvent
@@ -313,7 +313,7 @@ class ControlFlow:
                         has_control_connection = True
                         break
             # if there is a connection coming in, isn't a start.
-            if has_control_connection:
+            if has_control_connection and not isinstance(node, StartLoopNode):
                 continue
             # Does it have an outgoing connection?
             if node.name in cn_mgr.outgoing_index:

griptape_nodes/exe_types/node_types.py

@@ -581,6 +581,201 @@ class BaseNode(ABC):
             msg = f"Parameter '{parameter_name} doesn't exist on {self.name}'"
             raise RuntimeError(msg)
 
+    def reorder_elements(self, element_order: list[str | int]) -> None:
+        """Reorder the elements of this node.
+
+        Args:
+            element_order: A list of element names or indices in the desired order.
+                         Can mix names and indices. Names take precedence over indices.
+
+        Example:
+            # Reorder by names
+            node.reorder_elements(["element1", "element2", "element3"])
+
+            # Reorder by indices
+            node.reorder_elements([0, 2, 1])
+
+            # Mix names and indices
+            node.reorder_elements(["element1", 2, "element3"])
+        """
+        # Get current elements
+        current_elements = self.root_ui_element._children
+
+        # Create a new ordered list of elements
+        ordered_elements = []
+        for item in element_order:
+            if isinstance(item, str):
+                # Find element by name
+                element = self.root_ui_element.find_element_by_name(item)
+                if element is None:
+                    msg = f"Element '{item}' not found"
+                    raise ValueError(msg)
+                ordered_elements.append(element)
+            elif isinstance(item, int):
+                # Get element by index
+                if item < 0 or item >= len(current_elements):
+                    msg = f"Element index {item} out of range"
+                    raise ValueError(msg)
+                ordered_elements.append(current_elements[item])
+            else:
+                msg = "Element order must contain strings (names) or integers (indices)"
+                raise TypeError(msg)
+
+        # Verify we have all elements
+        if len(ordered_elements) != len(current_elements):
+            msg = "Element order must include all elements exactly once"
+            raise ValueError(msg)
+
+        # Remove all elements from root_ui_element
+        for element in current_elements:
+            self.root_ui_element.remove_child(element)
+
+        # Add elements back in the new order
+        for element in ordered_elements:
+            self.root_ui_element.add_child(element)
+
+    def move_element_to_position(self, element: str | int, position: str | int) -> None:
+        """Move a single element to a specific position in the element list.
+
+        Args:
+            element: The element to move, specified by name or index
+            position: The target position, which can be:
+                     - "first" to move to the beginning
+                     - "last" to move to the end
+                     - An integer index (0-based) for a specific position
+
+        Example:
+            # Move element to first position by name
+            node.move_element_to_position("element1", "first")
+
+            # Move element to last position by index
+            node.move_element_to_position(0, "last")
+
+            # Move element to specific position
+            node.move_element_to_position("element1", 2)
+        """
+        # Get list of all element names
+        element_names = [child.name for child in self.root_ui_element._children]
+
+        # Convert element index to name if needed
+        element = self._get_element_name(element, element_names)
+
+        # Create new order with moved element
+        new_order = element_names.copy()
+        idx = new_order.index(element)
+
+        # Handle special position values
+        if position == "first":
+            target_pos = 0
+        elif position == "last":
+            target_pos = len(new_order) - 1
+        elif isinstance(position, int):
+            if position < 0 or position >= len(new_order):
+                msg = f"Target position {position} out of range"
+                raise ValueError(msg)
+            target_pos = position
+        else:
+            msg = "Position must be 'first', 'last', or an integer index"
+            raise TypeError(msg)
+
+        # Remove element from current position and insert at target position
+        new_order.pop(idx)
+        new_order.insert(target_pos, element)
+
+        # Use reorder_elements to apply the move
+        self.reorder_elements(list(new_order))
+
+    def _get_element_name(self, element: str | int, element_names: list[str]) -> str:
+        """Convert an element identifier (name or index) to its name.
+
+        Args:
+            element: Element identifier, either a name (str) or index (int)
+            element_names: List of all element names
+
+        Returns:
+            The element name
+
+        Raises:
+            ValueError: If index is out of range
+        """
+        if isinstance(element, int):
+            if element < 0 or element >= len(element_names):
+                msg = f"Element index {element} out of range"
+                raise ValueError(msg)
+            return element_names[element]
+        return element
+
+    def swap_elements(self, elem1: str | int, elem2: str | int) -> None:
+        """Swap the positions of two elements.
+
+        Args:
+            elem1: First element to swap, specified by name or index
+            elem2: Second element to swap, specified by name or index
+
+        Example:
+            # Swap by names
+            node.swap_elements("element1", "element2")
+
+            # Swap by indices
+            node.swap_elements(0, 2)
+
+            # Mix names and indices
+            node.swap_elements("element1", 2)
+        """
+        # Get list of all element names
+        element_names = [child.name for child in self.root_ui_element._children]
+
+        # Convert indices to names if needed
+        elem1 = self._get_element_name(elem1, element_names)
+        elem2 = self._get_element_name(elem2, element_names)
+
+        # Create new order with swapped elements
+        new_order = element_names.copy()
+        idx1 = new_order.index(elem1)
+        idx2 = new_order.index(elem2)
+        new_order[idx1], new_order[idx2] = new_order[idx2], new_order[idx1]
+
+        # Use reorder_elements to apply the swap
+        self.reorder_elements(list(new_order))
+
+    def move_element_up_down(self, element: str | int, *, up: bool = True) -> None:
+        """Move an element up or down one position in the element list.
+
+        Args:
+            element: The element to move, specified by name or index
+            up: If True, move element up one position. If False, move down one position.
+
+        Example:
+            # Move element up by name
+            node.move_element_up_down("element1", up=True)
+
+            # Move element down by index
+            node.move_element_up_down(0, up=False)
+        """
+        # Get list of all element names
+        element_names = [child.name for child in self.root_ui_element._children]
+
+        # Convert index to name if needed
+        element = self._get_element_name(element, element_names)
+
+        # Create new order with moved element
+        new_order = element_names.copy()
+        idx = new_order.index(element)
+
+        if up:
+            if idx == 0:
+                msg = "Element is already at the top"
+                raise ValueError(msg)
+            new_order[idx], new_order[idx - 1] = new_order[idx - 1], new_order[idx]
+        else:
+            if idx == len(new_order) - 1:
+                msg = "Element is already at the bottom"
+                raise ValueError(msg)
+            new_order[idx], new_order[idx + 1] = new_order[idx + 1], new_order[idx]
+
+        # Use reorder_elements to apply the move
+        self.reorder_elements(list(new_order))
+
 
 class ControlNode(BaseNode):
     # Control Nodes may have one Control Input Port and at least one Control Output Port
@@ -620,6 +815,18 @@ class EndNode(BaseNode):
         self.add_parameter(ControlParameterInput())
 
 
+class StartLoopNode(BaseNode):
+    finished: bool
+    current_index: int
+    end_node: EndLoopNode | None = None
+    """Creating class for Start Loop Node in order to implement loop functionality in execution."""
+
+
+class EndLoopNode(BaseNode):
+    start_node: StartLoopNode | None = None
+    """Creating class for Start Loop Node in order to implement loop functionality in execution."""
+
+
 class Connection:
     source_node: BaseNode
     target_node: BaseNode

griptape_nodes/retained_mode/events/agent_events.py

@@ -0,0 +1,83 @@
+from dataclasses import dataclass, field
+
+from griptape.memory.structure import Run
+
+from griptape_nodes.retained_mode.events.base_events import (
+    RequestPayload,
+    ResultPayloadFailure,
+    ResultPayloadSuccess,
+    WorkflowNotAlteredMixin,
+)
+from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
+
+
+@dataclass
+@PayloadRegistry.register
+class RunAgentRequest(RequestPayload):
+    input: str
+
+
+@dataclass
+@PayloadRegistry.register
+class RunAgentResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    output: str
+
+
+@dataclass
+@PayloadRegistry.register
+class RunAgentResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    error: str
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConversationMemoryRequest(RequestPayload):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConversationMemoryResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    runs: list[Run]
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConversationMemoryResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class ConfigureAgentRequest(RequestPayload):
+    prompt_driver: dict = field(default_factory=dict)
+
+
+@dataclass
+@PayloadRegistry.register
+class ConfigureAgentResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class ConfigureAgentResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class ResetAgentConversationMemoryRequest(RequestPayload):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class ResetAgentConversationMemoryResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class ResetAgentConversationMemoryResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    pass

griptape_nodes/retained_mode/griptape_nodes.py

@@ -39,6 +39,7 @@ from griptape_nodes.utils.metaclasses import SingletonMeta
 
 if TYPE_CHECKING:
     from griptape_nodes.exe_types.node_types import BaseNode
+    from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
     from griptape_nodes.retained_mode.managers.arbitrary_code_exec_manager import (
         ArbitraryCodeExecManager,
     )
@@ -98,8 +99,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _arbitrary_code_exec_manager: ArbitraryCodeExecManager
     _operation_depth_manager: OperationDepthManager
     _static_files_manager: StaticFilesManager
+    _agent_manager: AgentManager
 
     def __init__(self) -> None:
+        from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
         from griptape_nodes.retained_mode.managers.arbitrary_code_exec_manager import (
             ArbitraryCodeExecManager,
         )
@@ -139,6 +142,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._static_files_manager = StaticFilesManager(
                 self._config_manager, self._secrets_manager, self._event_manager
             )
+            self._agent_manager = AgentManager(self._event_manager)
 
             # Assign handlers now that these are created.
             self._event_manager.assign_manager_to_request_type(
@@ -222,6 +226,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def StaticFilesManager(cls) -> StaticFilesManager:
         return GriptapeNodes.get_instance()._static_files_manager
 
+    @classmethod
+    def AgentManager(cls) -> AgentManager:
+        return GriptapeNodes.get_instance()._agent_manager
+
     @classmethod
     def clear_data(cls) -> None:
         # Get canvas