griptape-nodes 0.65.5__py3-none-any.whl → 0.66.0__py3-none-any.whl

griptape_nodes/machines/dag_builder.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
+import copy
 import logging
 from dataclasses import dataclass, field
 from enum import StrEnum
 from typing import TYPE_CHECKING
 
 from griptape_nodes.common.directed_graph import DirectedGraph
-from griptape_nodes.exe_types.base_iterative_nodes import BaseIterativeStartNode
+from griptape_nodes.exe_types.base_iterative_nodes import BaseIterativeEndNode, BaseIterativeStartNode
+from griptape_nodes.exe_types.connections import Direction
 from griptape_nodes.exe_types.core_types import ParameterTypeBuiltin
 from griptape_nodes.exe_types.node_types import NodeResolutionState
 
@@ -45,7 +47,7 @@ class DagBuilder:
     graphs: dict[str, DirectedGraph]  # Str is the name of the start node associated here.
     node_to_reference: dict[str, DagNode]
     graph_to_nodes: dict[str, set[str]]  # Track which nodes belong to which graph
-    start_node_candidates: dict[str, set[str]]
+    start_node_candidates: dict[str, dict[str, set[str]]]  # {data_node: {graph: {boundary_nodes}}}
 
     def __init__(self) -> None:
         self.graphs = {}
@@ -53,8 +55,31 @@ class DagBuilder:
         self.graph_to_nodes = {}
         self.start_node_candidates = {}
 
+    def _get_nodes_to_exclude_for_iterative_end(self, node: BaseNode, connections: Connections) -> set[str]:
+        """Get nodes to exclude when collecting dependencies for BaseIterativeEndNode.
+
+        Args:
+            node: The node being processed
+            connections: The connections manager
+
+        Returns:
+            Set of node names to exclude (empty if not BaseIterativeEndNode)
+
+        Raises:
+            ValueError: If node is BaseIterativeEndNode but start_node is None
+        """
+        if not isinstance(node, BaseIterativeEndNode):
+            return set()
+
+        if node.start_node is None:
+            error_msg = f"Error: {node.name} is not properly connected to a start node"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        return self.collect_loop_body_nodes(node.start_node, node, connections)
+
     # Complex with the inner recursive method, but it needs connections and added_nodes.
-    def add_node_with_dependencies(self, node: BaseNode, graph_name: str = "default") -> list[BaseNode]:
+    def add_node_with_dependencies(self, node: BaseNode, graph_name: str = "default") -> list[BaseNode]:  # noqa: C901
         """Add node and all its dependencies to DAG. Returns list of added nodes."""
         from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
@@ -66,6 +91,9 @@ class DagBuilder:
             self.graphs[graph_name] = graph
             self.graph_to_nodes[graph_name] = set()
 
+        # Get nodes to exclude for BaseIterativeEndNode (loop body nodes)
+        nodes_to_exclude = self._get_nodes_to_exclude_for_iterative_end(node, connections)
+
         def _add_node_recursive(current_node: BaseNode, visited: set[str], graph: DirectedGraph) -> None:
             # Skip if already visited or already in DAG
             if current_node.name in visited:
@@ -102,6 +130,10 @@ class DagBuilder:
 
                 upstream_node, _ = upstream_connection
 
+                # Skip nodes in exclusion set (for BaseIterativeEndNode loop body)
+                if upstream_node.name in nodes_to_exclude:
+                    continue
+
                 # Skip already resolved nodes
                 if upstream_node.state == NodeResolutionState.RESOLVED:
                     continue
@@ -114,6 +146,14 @@ class DagBuilder:
 
         _add_node_recursive(node, set(), graph)
 
+        # Special handling for BaseIterativeEndNode: add start_node as dependency
+        if isinstance(node, BaseIterativeEndNode) and node.start_node is not None:
+            # Add start_node and its dependencies
+            _add_node_recursive(node.start_node, set(), graph)
+            # Add edge from start_node to end_node
+            if node.start_node.name in graph.nodes() and node.name in graph.nodes():
+                graph.add_edge(node.start_node.name, node.name)
+
         return added_nodes
 
     def add_node(self, node: BaseNode, graph_name: str = "default") -> DagNode:
@@ -171,8 +211,15 @@ class DagBuilder:
                     if root_node == node.node_reference:
                         continue
 
+                    # Skip if the root node is the end node of a start node. It's technically not downstream.
+                    if (
+                        isinstance(node.node_reference, BaseIterativeStartNode)
+                        and root_node == node.node_reference.end_node
+                    ):
+                        continue
+
                     # Check if the target node is in the forward path from this root
-                    if self._is_node_in_forward_path(root_node, node.node_reference, connections):
+                    if connections.is_node_in_forward_control_path(root_node, node.node_reference):
                         return False  # This graph could still reach the target node
 
         # Otherwise, return true at the end of the function
@@ -250,6 +297,49 @@ class DagBuilder:
 
         return nodes_in_path
 
+    @staticmethod
+    def collect_loop_body_nodes(
+        start_node: BaseIterativeStartNode, end_node: BaseIterativeEndNode, connections: Connections
+    ) -> set[str]:
+        """Collect all nodes in the loop body between start_node and end_node.
+
+        This walks through all outgoing connections from start_node and stops when
+        reaching end_node, collecting all intermediate nodes.
+
+        Args:
+            start_node: The iterative start node
+            end_node: The iterative end node
+            connections: The connections manager
+
+        Returns:
+            Set of node names in the loop body (between start and end, exclusive)
+        """
+        loop_body_nodes: set[str] = set()
+        to_visit = []
+        to_visit.append(start_node)
+        visited = set()
+        while to_visit:
+            current_node = to_visit.pop(0)
+
+            if current_node.name in visited:
+                continue
+            visited.add(current_node.name)
+            # Don't add start or end nodes themselves
+            if current_node not in (start_node, end_node):
+                loop_body_nodes.add(current_node.name)
+            # Stop traversal if we've reached the end node
+            if current_node == end_node:
+                continue
+            for param in current_node.parameters:
+                downstream_connection = connections.get_connected_node(
+                    current_node, param, direction=Direction.DOWNSTREAM, include_internal=False
+                )
+                if downstream_connection:
+                    next_node = downstream_connection.node
+                    if next_node.name not in visited:
+                        to_visit.append(next_node)
+        return loop_body_nodes
+
     @staticmethod
     def collect_data_dependencies_for_node(
         node: BaseNode, connections: Connections, nodes_to_exclude: set[str], visited: set[str]
@@ -302,39 +392,6 @@ class DagBuilder:
 
         return dependencies
 
-    def _is_node_in_forward_path(
-        self, start_node: BaseNode, target_node: BaseNode, connections: Connections, visited: set[str] | None = None
-    ) -> bool:
-        """Check if target_node is reachable from start_node through control flow connections."""
-        if visited is None:
-            visited = set()
-
-        if start_node.name in visited:
-            return False
-        visited.add(start_node.name)
-
-        # Check ALL outgoing control connections, not just get_next_control_output()
-        # This handles IfElse nodes that have multiple possible control outputs
-        if start_node.name in connections.outgoing_index:
-            for param_name, connection_ids in connections.outgoing_index[start_node.name].items():
-                # Find the parameter to check if it's a control type
-                param = start_node.get_parameter_by_name(param_name)
-                if param and param.output_type == ParameterTypeBuiltin.CONTROL_TYPE.value:
-                    # This is a control parameter - check all its connections
-                    for connection_id in connection_ids:
-                        if connection_id in connections.connections:
-                            connection = connections.connections[connection_id]
-                            next_node = connection.target_node
-
-                            if next_node.name == target_node.name:
-                                return True
-
-                            # Recursively check the forward path
-                            if self._is_node_in_forward_path(next_node, target_node, connections, visited):
-                                return True
-
-        return False
-
     def cleanup_empty_graph_nodes(self, graph_name: str) -> None:
         """Remove nodes from node_to_reference when their graph becomes empty (only in single node resolution)."""
         if graph_name in self.graph_to_nodes:
@@ -342,21 +399,30 @@ class DagBuilder:
                 self.node_to_reference.pop(node_name, None)
             self.graph_to_nodes.pop(graph_name, None)
 
-    def remove_graph_from_dependencies(self) -> list[str]:
-        # Check all start node candidates and return those whose dependent graphs are all empty
-        start_nodes = []
-        # copy because we will be removing as iterating.
-        for start_node_name, graph_deps in self.start_node_candidates.copy().items():
-            # Check if all graphs this start node depends on are now empty
-            all_deps_empty = True
-            for graph_deps_name in graph_deps:
-                # Check if this graph exists and has nodes
-                if graph_deps_name in self.graphs and len(self.graphs[graph_deps_name].nodes()) > 0:
-                    all_deps_empty = False
-                    break
-
-            # If all dependent graphs are empty, this start node can be queued
-            if all_deps_empty:
-                del self.start_node_candidates[start_node_name]
-                start_nodes.append(start_node_name)
-        return start_nodes
+    def remove_node_from_dependencies(self, completed_node: str, graph_name: str) -> list[str]:
+        """Remove completed node from all dependencies, return nodes ready to execute.
+
+        Args:
+            completed_node: Name of the node that just completed
+            graph_name: Name of the graph the node completed in
+
+        Returns:
+            List of data node names that are now ready to execute
+        """
+        newly_available = []
+
+        for data_node, graph_deps in copy.deepcopy(list(self.start_node_candidates.items())):
+            if graph_name in graph_deps:
+                # Remove the completed node from this graph's boundary nodes
+                graph_deps[graph_name].discard(completed_node)
+
+                # If all boundary nodes from this graph have completed, remove the graph dependency
+                if len(graph_deps[graph_name]) == 0:
+                    del graph_deps[graph_name]
+
+                # If all graph dependencies are satisfied, the data node is ready
+                if len(graph_deps) == 0:
+                    del self.start_node_candidates[data_node]
+                    newly_available.append(data_node)
+
+        return newly_available

griptape_nodes/machines/fsm.py

@@ -1,8 +1,18 @@
+from enum import StrEnum
 from typing import Any, TypeVar
 
 T = TypeVar("T")
 
 
+class WorkflowState(StrEnum):
+    """Workflow execution states."""
+
+    NO_ERROR = "no_error"
+    WORKFLOW_COMPLETE = "workflow_complete"
+    ERRORED = "errored"
+    CANCELED = "canceled"
+
+
 class State:
     @staticmethod
     async def on_enter(context: Any) -> type["State"] | None:  # noqa: ARG004

griptape_nodes/machines/parallel_resolution.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from enum import StrEnum
 from typing import TYPE_CHECKING
 
 from griptape_nodes.exe_types.base_iterative_nodes import BaseIterativeEndNode, BaseIterativeStartNode
@@ -14,7 +13,7 @@ from griptape_nodes.exe_types.node_types import (
 )
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.machines.dag_builder import NodeState
-from griptape_nodes.machines.fsm import FSM, State
+from griptape_nodes.machines.fsm import FSM, State, WorkflowState
 from griptape_nodes.node_library.library_registry import LibraryRegistry
 from griptape_nodes.retained_mode.events.base_events import (
     ExecutionEvent,
@@ -41,15 +40,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger("griptape_nodes")
 
 
-class WorkflowState(StrEnum):
-    """Workflow execution states."""
-
-    NO_ERROR = "no_error"
-    WORKFLOW_COMPLETE = "workflow_complete"
-    ERRORED = "errored"
-    CANCELED = "canceled"
-
-
 class ParallelResolutionContext:
     paused: bool
     flow_name: str
@@ -60,7 +50,6 @@ class ParallelResolutionContext:
     task_to_node: dict[asyncio.Task, DagNode]
     dag_builder: DagBuilder | None
     last_resolved_node: BaseNode | None  # Track the last node that was resolved
-    last_resolved_node: BaseNode | None  # Track the last node that was resolved
 
     def __init__(
         self, flow_name: str, max_nodes_in_parallel: int | None = None, dag_builder: DagBuilder | None = None
@@ -116,7 +105,21 @@ class ParallelResolutionContext:
 
 class ExecuteDagState(State):
     @staticmethod
-    async def handle_done_nodes(context: ParallelResolutionContext, done_node: DagNode, network_name: str) -> None:  # noqa: C901
+    def check_for_new_start_nodes(
+        context: ParallelResolutionContext, current_node_name: str, network_name: str
+    ) -> None:
+        # Remove this node from dependencies and get newly available nodes
+        if context.dag_builder is not None:
+            newly_available = context.dag_builder.remove_node_from_dependencies(current_node_name, network_name)
+            for data_node_name in newly_available:
+                data_node = GriptapeNodes.NodeManager().get_node_by_name(data_node_name)
+                added_nodes = context.dag_builder.add_node_with_dependencies(data_node, data_node_name)
+                if added_nodes:
+                    for added_node in added_nodes:
+                        ExecuteDagState._try_queue_waiting_node(context, added_node.name)
+
+    @staticmethod
+    async def handle_done_nodes(context: ParallelResolutionContext, done_node: DagNode, network_name: str) -> None:
         current_node = done_node.node_reference
 
         # Check if node was already resolved (shouldn't happen)
@@ -194,13 +197,7 @@ class ExecuteDagState(State):
         )
         # Now the final thing to do, is to take their directed graph and update it.
         ExecuteDagState.get_next_control_graph(context, current_node, network_name)
-        graph = context.networks[network_name]
-        if len(graph.nodes()) == 0 and context.dag_builder is not None:
-            # remove from dependencies. This is so we can potentially queue the data node.
-            data_start_nodes = context.dag_builder.remove_graph_from_dependencies()
-            for data_start_node_name in data_start_nodes:
-                data_start_node = GriptapeNodes.NodeManager().get_node_by_name(data_start_node_name)
-                context.dag_builder.add_node_with_dependencies(data_start_node, network_name)
+        ExecuteDagState.check_for_new_start_nodes(context, current_node.name, network_name)
 
     @staticmethod
     def get_next_control_graph(context: ParallelResolutionContext, node: BaseNode, network_name: str) -> None:
@@ -227,7 +224,8 @@ class ExecuteDagState(State):
         if network is None:
             msg = f"Network {network_name} not found in DAG builder"
             raise ValueError(msg)
-        if flow_manager.global_single_node_resolution:
+        is_isolated = context.dag_builder is not flow_manager.global_dag_builder
+        if flow_manager.global_single_node_resolution and not is_isolated:
             # Clean up nodes from emptied graphs in single node resolution mode
             if len(network) == 0 and context.dag_builder is not None:
                 context.dag_builder.cleanup_empty_graph_nodes(network_name)
@@ -354,7 +352,7 @@ class ExecuteDagState(State):
                     )
                 )
                 if isinstance(result, SetParameterValueResultFailure):
-                    msg = f"Failed to set value for parameter '{parameter.name}' on node '{current_node.name}': {result.result_details}"
+                    msg = f"Failed to set parameter value for node '{current_node.name}' and parameter '{parameter.name}'. Details: {result.result_details}"
                     logger.error(msg)
                     raise RuntimeError(msg)
 
@@ -390,7 +388,9 @@ class ExecuteDagState(State):
         networks = context.networks
         handled_nodes = set()  # Track nodes we've already processed to avoid duplicates
 
-        for network_name, network in networks.items():
+        # Create a copy of items to avoid "dictionary changed size during iteration" error
+        # This is necessary because handle_done_nodes can add new networks via the DAG builder
+        for network_name, network in list(networks.items()):
             # Check and see if there are leaf nodes that are cancelled.
             # Reinitialize leaf nodes since maybe we changed things up.
             # We removed nodes from the network. There may be new leaf nodes.
@@ -481,8 +481,10 @@ class ExecuteDagState(State):
             node_reference.node_reference.parameter_output_values.silent_clear()
             exceptions = node_reference.node_reference.validate_before_node_run()
             if exceptions:
-                msg = f"Canceling flow run. Node '{node_reference.node_reference.name}' encountered problems: {exceptions}"
-                logger.error(msg)
+                msg = f"Node '{node_reference.node_reference.name}' encountered problems: {exceptions}"
+                logger.error("Canceling flow run. %s", msg)
+                context.error_message = msg
+                context.workflow_state = WorkflowState.ERRORED
                 return ErrorState
 
             # We've set up the node for success completely. Now we check and handle accordingly if it's a for-each-start node
@@ -497,6 +499,8 @@ class ExecuteDagState(State):
                         f"Cannot have a Start Loop Node without an End Loop Node: {node_reference.node_reference.name}"
                     )
                     logger.error(msg)
+                    context.error_message = msg
+                    context.workflow_state = WorkflowState.ERRORED
                     return ErrorState
                 # We're going to skip straight to the end node here instead.
                 # Set end node to node reference
@@ -551,18 +555,12 @@ class ExecuteDagState(State):
                     exc = task.exception()
                     dag_node = context.task_to_node.get(task)
                     node_name = dag_node.node_reference.name if dag_node else "Unknown"
-                    node_type = dag_node.node_reference.__class__.__name__ if dag_node else "Unknown"
-
-                    logger.exception(
-                        "Task execution failed for node '%s' (type: %s) in flow '%s'. Exception: %s",
-                        node_name,
-                        node_type,
-                        context.flow_name,
-                        exc,
-                    )
+
+                    logger.exception("Error processing node '%s'", node_name)
+                    msg = f"Node '{node_name}' encountered a problem: {exc}"
 
                     context.task_to_node.pop(task)
-                    context.error_message = f"Task execution failed for node '{node_name}': {exc}"
+                    context.error_message = msg
                     context.workflow_state = WorkflowState.ERRORED
                     return ErrorState
                 context.task_to_node.pop(task)
@@ -578,9 +576,6 @@ class ExecuteDagState(State):
 class ErrorState(State):
     @staticmethod
     async def on_enter(context: ParallelResolutionContext) -> type[State] | None:
-        if context.error_message:
-            logger.error("DAG execution error: %s", context.error_message)
-
         for node in context.node_to_reference.values():
             # Cancel all nodes that haven't yet begun processing.
             if node.node_state == NodeState.QUEUED:
@@ -676,3 +671,9 @@ class ParallelResolutionMachine(FSM[ParallelResolutionContext]):
     def get_last_resolved_node(self) -> BaseNode | None:
         """Get the last node that was resolved in the DAG execution."""
         return self._context.last_resolved_node
+
+    def is_errored(self) -> bool:
+        return self._context.workflow_state == WorkflowState.ERRORED
+
+    def get_error_message(self) -> str | None:
+        return self._context.error_message

griptape_nodes/machines/sequential_resolution.py

@@ -9,7 +9,7 @@ from griptape_nodes.exe_types.connections import Direction
 from griptape_nodes.exe_types.core_types import ParameterTypeBuiltin
 from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
 from griptape_nodes.exe_types.type_validator import TypeValidator
-from griptape_nodes.machines.fsm import FSM, State
+from griptape_nodes.machines.fsm import FSM, State, WorkflowState
 from griptape_nodes.node_library.library_registry import LibraryRegistry
 from griptape_nodes.retained_mode.events.base_events import (
     ExecutionEvent,
@@ -42,10 +42,14 @@ class Focus:
 class ResolutionContext:
     focus_stack: list[Focus]
     paused: bool
+    error_message: str | None
+    workflow_state: WorkflowState
 
     def __init__(self) -> None:
         self.focus_stack = []
         self.paused = False
+        self.error_message = None
+        self.workflow_state = WorkflowState.NO_ERROR
 
     @property
     def current_node(self) -> BaseNode:
@@ -62,6 +66,8 @@ class ResolutionContext:
             node.clear_node()
         self.focus_stack.clear()
         self.paused = False
+        self.error_message = None
+        self.workflow_state = WorkflowState.NO_ERROR
 
 
 class InitializeSpotlightState(State):
@@ -260,7 +266,10 @@ class ExecuteNodeState(State):
 
         exceptions = current_node.validate_before_node_run()
         if exceptions:
-            msg = f"Canceling flow run. Node '{current_node.name}' encountered problems: {exceptions}"
+            msg = f"Node '{current_node.name}' encountered problems: {exceptions}"
+            logger.error("Canceling flow run. %s", msg)
+            context.error_message = msg
+            context.workflow_state = WorkflowState.ERRORED
             # Mark the node as unresolved, broadcasting to everyone.
             raise RuntimeError(msg)
         if not context.paused:
@@ -268,7 +277,7 @@ class ExecuteNodeState(State):
         return None
 
     @staticmethod
-    async def on_update(context: ResolutionContext) -> type[State] | None:
+    async def on_update(context: ResolutionContext) -> type[State] | None:  # noqa: PLR0915
         from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
         # Once everything has been set
@@ -305,10 +314,21 @@ class ExecuteNodeState(State):
                         wrapped_event=ExecutionEvent(payload=NodeFinishProcessEvent(node_name=current_node.name))
                     )
                 )
+                msg = f"Node '{current_node.name}' encountered a problem that cancelled the task."
+                context.error_message = msg
+                context.workflow_state = WorkflowState.ERRORED
+                # Mark the node as unresolved, broadcasting to everyone.
+                current_node.make_node_unresolved(
+                    current_states_to_trigger_change_event=set(
+                        {NodeResolutionState.UNRESOLVED, NodeResolutionState.RESOLVED, NodeResolutionState.RESOLVING}
+                    )
+                )
                 return CompleteState
             except Exception as e:
                 logger.exception("Error processing node '%s", current_node.name)
                 msg = f"Node '{current_node.name}' encountered a problem: {e}"
+                context.error_message = msg
+                context.workflow_state = WorkflowState.ERRORED
                 # Mark the node as unresolved, broadcasting to everyone.
                 current_node.make_node_unresolved(
                     current_states_to_trigger_change_event=set(
@@ -449,6 +469,12 @@ class SequentialResolutionMachine(FSM[ResolutionContext]):
     def is_started(self) -> bool:
         return self._current_state is not None
 
+    def is_errored(self) -> bool:
+        return self._context.workflow_state == WorkflowState.ERRORED
+
+    def get_error_message(self) -> str | None:
+        return self._context.error_message
+
     # Unused argument but necessary for parallel_resolution because of futures ending during cancel but not reset.
     def reset_machine(self, *, cancel: bool = False) -> None:  # noqa: ARG002
         self._context.reset()

griptape_nodes/node_library/library_registry.py

@@ -3,11 +3,14 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any, ClassVar, NamedTuple
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from griptape_nodes.retained_mode.managers.fitness_problems.libraries.duplicate_node_registration_problem import (
     DuplicateNodeRegistrationProblem,
 )
+from griptape_nodes.retained_mode.managers.resource_components.resource_instance import (
+    Requirements,  # noqa: TC001 (putting this into type checking causes it to not be defined for Pydantic field_validator)
+)
 from griptape_nodes.utils.metaclasses import SingletonMeta
 
 if TYPE_CHECKING:
@@ -34,6 +37,40 @@ class Dependencies(BaseModel):
     pip_install_flags: list[str] | None = None
 
 
+class ResourceRequirements(BaseModel):
+    """Resource requirements for a library.
+
+    Specifies what system resources (OS, compute backends) the library needs.
+    Example: {"platform": (["linux", "windows"], "has_any"), "arch": "x86_64", "compute": (["cuda", "cpu"], "has_all")}
+    """
+
+    required: Requirements | None = None
+
+    @field_validator("required", mode="before")
+    @classmethod
+    def convert_lists_to_tuples(cls, v: Any) -> Any:
+        """Convert list values to tuples for requirements loaded from JSON.
+
+        JSON arrays become Python lists, but the Requirements type expects tuples
+        for (value, comparator) pairs.
+        """
+        if v is None:
+            return None
+
+        if not isinstance(v, dict):
+            return v
+
+        converted = {}
+        comparator_tuple_length = 2
+        for key, value in v.items():
+            # Check if value is a list with exactly 2 elements where second is a string (comparator)
+            if isinstance(value, list) and len(value) == comparator_tuple_length and isinstance(value[1], str):
+                converted[key] = tuple(value)
+            else:
+                converted[key] = value
+        return converted
+
+
 class LibraryMetadata(BaseModel):
     """Metadata that explains details about the library, including versioning and search details."""
 
@@ -45,6 +82,8 @@ class LibraryMetadata(BaseModel):
     dependencies: Dependencies | None = None
     # If True, this library will be surfaced to Griptape Nodes customers when listing Node Libraries available to them.
     is_griptape_nodes_searchable: bool = True
+    # Resource requirements for this library. If None, library is assumed to work on any platform.
+    resources: ResourceRequirements | None = None
 
 
 class IconVariant(BaseModel):
@@ -112,7 +151,7 @@ class LibrarySchema(BaseModel):
     library itself.
     """
 
-    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.3.0"
+    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.4.0"
 
     name: str
     library_schema_version: str