griptape-nodes 0.60.4__py3-none-any.whl → 0.61.0__py3-none-any.whl

griptape_nodes/retained_mode/events/project_events.py

@@ -0,0 +1,413 @@
+"""Events for project template management."""
+
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+from griptape_nodes.common.macro_parser import MacroMatchFailure, MacroParseFailure, VariableInfo
+from griptape_nodes.common.project_templates import ProjectTemplate, ProjectValidationInfo
+from griptape_nodes.retained_mode.events.base_events import (
+    RequestPayload,
+    ResultPayloadFailure,
+    ResultPayloadSuccess,
+    WorkflowNotAlteredMixin,
+)
+from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
+
+# Type alias for macro variable dictionaries (used by ParsedMacro)
+MacroVariables = dict[str, str | int]
+
+
+class PathResolutionFailureReason(StrEnum):
+    """Reason why path resolution from macro failed."""
+
+    MISSING_REQUIRED_VARIABLES = "MISSING_REQUIRED_VARIABLES"
+    MACRO_RESOLUTION_ERROR = "MACRO_RESOLUTION_ERROR"
+    DIRECTORY_OVERRIDE_ATTEMPTED = "DIRECTORY_OVERRIDE_ATTEMPTED"
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadProjectTemplateRequest(RequestPayload):
+    """Load user's project.yml and merge with system defaults.
+
+    Use when: User opens a workspace, user creates new project, user modifies project.yml.
+
+    Args:
+        project_path: Path to the project.yml file to load
+
+    Results: LoadProjectTemplateResultSuccess | LoadProjectTemplateResultFailure
+    """
+
+    project_path: Path
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadProjectTemplateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Project template loaded successfully.
+
+    Args:
+        project_path: Path to the loaded project.yml
+        template: The merged ProjectTemplate (system defaults + user customizations)
+        validation: Validation info with status and any problems encountered
+    """
+
+    project_path: Path
+    template: ProjectTemplate
+    validation: ProjectValidationInfo
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadProjectTemplateResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Project template loading failed.
+
+    Args:
+        project_path: Path to the project.yml that failed to load
+        validation: Validation info with error details
+    """
+
+    project_path: Path
+    validation: ProjectValidationInfo
+
+
+@dataclass
+@PayloadRegistry.register
+class GetProjectTemplateRequest(RequestPayload):
+    """Get cached project template for a workspace path.
+
+    Use when: Querying current project configuration, checking validation status.
+
+    Args:
+        project_path: Path to the project.yml file
+
+    Results: GetProjectTemplateResultSuccess | GetProjectTemplateResultFailure
+    """
+
+    project_path: Path
+
+
+@dataclass
+@PayloadRegistry.register
+class GetProjectTemplateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Project template retrieved from cache.
+
+    Args:
+        template: The successfully loaded ProjectTemplate
+        validation: Validation info for the template
+    """
+
+    template: ProjectTemplate
+    validation: ProjectValidationInfo
+
+
+@dataclass
+@PayloadRegistry.register
+class GetProjectTemplateResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Project template retrieval failed (not loaded yet)."""
+
+
+@dataclass
+@PayloadRegistry.register
+class GetMacroForSituationRequest(RequestPayload):
+    """Get the macro schema for a specific situation.
+
+    Use when: Need to know what variables a situation requires, or get schema for custom resolution.
+
+    Args:
+        project_path: Path to the project.yml to use
+        situation_name: Name of the situation template (e.g., "save_node_output")
+
+    Results: GetMacroForSituationResultSuccess | GetMacroForSituationResultFailure
+    """
+
+    project_path: Path
+    situation_name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class GetMacroForSituationResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Situation macro retrieved successfully.
+
+    Args:
+        macro_schema: The macro template string (e.g., "{inputs}/{file_name}.{file_ext}")
+    """
+
+    macro_schema: str
+
+
+@dataclass
+@PayloadRegistry.register
+class GetMacroForSituationResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Situation macro retrieval failed (situation not found or template not loaded)."""
+
+
+@dataclass
+@PayloadRegistry.register
+class GetPathForMacroRequest(RequestPayload):
+    """Resolve ANY macro schema with variables to produce final file path.
+
+    Use when: Resolving paths, saving files. Works with any macro string, not tied to situations.
+
+    Args:
+        project_path: Path to the project.yml (used for directory resolution)
+        macro_schema: The macro template string to resolve (e.g., "{inputs}/{file_name}.{file_ext}")
+        variables: Variable values for macro substitution (e.g., {"file_name": "output", "file_ext": "png"})
+
+    Results: GetPathForMacroResultSuccess | GetPathForMacroResultFailure
+    """
+
+    project_path: Path
+    macro_schema: str
+    variables: MacroVariables
+
+
+@dataclass
+@PayloadRegistry.register
+class GetPathForMacroResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Path resolved successfully from macro.
+
+    Args:
+        resolved_path: The final Path after macro substitution
+    """
+
+    resolved_path: Path
+
+
+@dataclass
+@PayloadRegistry.register
+class GetPathForMacroResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Path resolution failed.
+
+    Args:
+        failure_reason: Specific reason for failure
+        missing_variables: List of required variable names that were not provided (for MISSING_REQUIRED_VARIABLES)
+        conflicting_variables: List of variables that conflict with directory names (for DIRECTORY_OVERRIDE_ATTEMPTED)
+        error_details: Additional error details from ParsedMacro (for MACRO_RESOLUTION_ERROR)
+    """
+
+    failure_reason: PathResolutionFailureReason
+    missing_variables: list[str] | None = None
+    conflicting_variables: list[str] | None = None
+    error_details: str | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class SetCurrentProjectRequest(RequestPayload):
+    """Set which project.yml user has currently selected.
+
+    Use when: User switches between projects, opens a new workspace.
+
+    Args:
+        project_path: Path to the project.yml to set as current (None to clear)
+
+    Results: SetCurrentProjectResultSuccess
+    """
+
+    project_path: Path | None
+
+
+@dataclass
+@PayloadRegistry.register
+class SetCurrentProjectResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Current project set successfully."""
+
+
+@dataclass
+@PayloadRegistry.register
+class GetCurrentProjectRequest(RequestPayload):
+    """Get the currently selected project path.
+
+    Use when: Need to know which project user is working with.
+
+    Results: GetCurrentProjectResultSuccess
+    """
+
+
+@dataclass
+@PayloadRegistry.register
+class GetCurrentProjectResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Current project retrieved.
+
+    Args:
+        project_path: The currently selected project path ("No Project" if None)
+    """
+
+    project_path: Path | None
+
+
+@dataclass
+@PayloadRegistry.register
+class SaveProjectTemplateRequest(RequestPayload):
+    """Save user customizations to project.yml file.
+
+    Use when: User modifies project configuration, exports template.
+
+    Args:
+        project_path: Path where project.yml should be saved
+        template_data: Dict representation of the template to save
+
+    Results: SaveProjectTemplateResultSuccess | SaveProjectTemplateResultFailure
+    """
+
+    project_path: Path
+    template_data: dict[str, Any]
+
+
+@dataclass
+@PayloadRegistry.register
+class SaveProjectTemplateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Project template saved successfully.
+
+    Args:
+        project_path: Path where project.yml was saved
+    """
+
+    project_path: Path
+
+
+@dataclass
+@PayloadRegistry.register
+class SaveProjectTemplateResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Project template save failed.
+
+    Common causes:
+    - Permission denied
+    - Invalid path
+    - Disk full
+    """
+
+    project_path: Path
+
+
+@dataclass
+@PayloadRegistry.register
+class MatchPathAgainstMacroRequest(RequestPayload):
+    """Check if a path matches a macro schema and extract variables.
+
+    Use when: Validating paths, extracting info from file paths,
+    identifying which schema produced a file.
+
+    Args:
+        project_path: Path to project.yml (for directory resolution)
+        macro_schema: Macro template string
+        file_path: Path to test
+        known_variables: Variables we already know
+
+    Results: MatchPathAgainstMacroResultSuccess | MatchPathAgainstMacroResultFailure
+    """
+
+    project_path: Path
+    macro_schema: str
+    file_path: str
+    known_variables: MacroVariables
+
+
+@dataclass
+@PayloadRegistry.register
+class MatchPathAgainstMacroResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Path matched the macro schema."""
+
+    extracted_variables: MacroVariables
+
+
+@dataclass
+@PayloadRegistry.register
+class MatchPathAgainstMacroResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Path did not match the macro schema."""
+
+    match_failure: MacroMatchFailure
+
+
+@dataclass
+@PayloadRegistry.register
+class GetVariablesForMacroRequest(RequestPayload):
+    """Get list of all variables in a macro schema.
+
+    Use when: Building UI forms, showing what variables a schema needs,
+    validating before resolution.
+
+    Args:
+        macro_schema: Macro template string to inspect
+
+    Results: GetVariablesForMacroResultSuccess | GetVariablesForMacroResultFailure
+    """
+
+    macro_schema: str
+
+
+@dataclass
+@PayloadRegistry.register
+class GetVariablesForMacroResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Variables found in the macro schema."""
+
+    variables: list[VariableInfo]
+
+
+@dataclass
+@PayloadRegistry.register
+class GetVariablesForMacroResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failed to parse macro schema."""
+
+    parse_failure: MacroParseFailure
+
+
+@dataclass
+@PayloadRegistry.register
+class ValidateMacroSyntaxRequest(RequestPayload):
+    """Validate a macro schema string for syntax errors.
+
+    Use when: User editing schemas in UI, before saving templates,
+    real-time validation.
+
+    Args:
+        macro_schema: Schema string to validate
+
+    Results: ValidateMacroSyntaxResultSuccess | ValidateMacroSyntaxResultFailure
+    """
+
+    macro_schema: str
+
+
+@dataclass
+@PayloadRegistry.register
+class ValidateMacroSyntaxResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Syntax is valid."""
+
+    variables: list[VariableInfo]
+    warnings: list[str]
+
+
+@dataclass
+@PayloadRegistry.register
+class ValidateMacroSyntaxResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Syntax is invalid."""
+
+    parse_failure: MacroParseFailure
+    partial_variables: list[VariableInfo]
+
+
+@dataclass
+@PayloadRegistry.register
+class GetAllSituationsForProjectRequest(RequestPayload):
+    """Get all situation names and schemas from a project template."""
+
+    project_path: Path
+
+
+@dataclass
+@PayloadRegistry.register
+class GetAllSituationsForProjectResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Success result containing all situations."""
+
+    situations: dict[str, str]
+
+
+@dataclass
+@PayloadRegistry.register
+class GetAllSituationsForProjectResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failure result when cannot get situations."""

griptape_nodes/retained_mode/events/workflow_events.py

@@ -10,6 +10,7 @@ from griptape_nodes.retained_mode.events.base_events import (
     WorkflowAlteredMixin,
     WorkflowNotAlteredMixin,
 )
+from griptape_nodes.retained_mode.events.execution_events import ExecutionPayload
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
 if TYPE_CHECKING:
@@ -388,9 +389,11 @@ class PublishWorkflowRequest(RequestPayload):
 
     workflow_name: str
     publisher_name: str
-    execute_on_publish: bool = False
+    # This can be removed after GUI release
+    execute_on_publish: bool | None = None
     published_workflow_file_name: str | None = None
     pickle_control_flow_result: bool = False
+    metadata: dict | None = None
 
 
 @dataclass
@@ -403,6 +406,7 @@ class PublishWorkflowResultSuccess(ResultPayloadSuccess):
     """
 
     published_workflow_file_path: str
+    metadata: dict | None = None
 
 
 @dataclass
@@ -411,6 +415,20 @@ class PublishWorkflowResultFailure(ResultPayloadFailure):
     """Workflow publish failed. Common causes: workflow not found, publish error, file system error."""
 
 
+@dataclass
+@PayloadRegistry.register
+class PublishWorkflowProgressEvent(ExecutionPayload):
+    """Event emitted to indicate progress during workflow publishing.
+
+    Args:
+        progress: Progress percentage (0-100)
+        message: Optional progress message
+    """
+
+    progress: float
+    message: str | None = None
+
+
 @dataclass
 @PayloadRegistry.register
 class BranchWorkflowRequest(RequestPayload):

griptape_nodes/retained_mode/griptape_nodes.py

@@ -51,6 +51,7 @@ if TYPE_CHECKING:
         OperationDepthManager,
     )
     from griptape_nodes.retained_mode.managers.os_manager import OSManager
+    from griptape_nodes.retained_mode.managers.project_manager import ProjectManager
     from griptape_nodes.retained_mode.managers.resource_manager import ResourceManager
     from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
     from griptape_nodes.retained_mode.managers.session_manager import SessionManager
@@ -95,8 +96,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _resource_manager: ResourceManager
     _sync_manager: SyncManager
     _user_manager: UserManager
+    _project_manager: ProjectManager
 
-    def __init__(self) -> None:
+    def __init__(self) -> None:  # noqa: PLR0915
         from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
         from griptape_nodes.retained_mode.managers.arbitrary_code_exec_manager import (
             ArbitraryCodeExecManager,
@@ -115,6 +117,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             OperationDepthManager,
         )
         from griptape_nodes.retained_mode.managers.os_manager import OSManager
+        from griptape_nodes.retained_mode.managers.project_manager import ProjectManager
         from griptape_nodes.retained_mode.managers.resource_manager import ResourceManager
         from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
         from griptape_nodes.retained_mode.managers.session_manager import SessionManager
@@ -160,6 +163,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._mcp_manager = MCPManager(self._event_manager, self._config_manager)
             self._sync_manager = SyncManager(self._event_manager, self._config_manager)
             self._user_manager = UserManager(self._secrets_manager)
+            self._project_manager = ProjectManager(self._event_manager, self._config_manager, self._secrets_manager)
 
             # Assign handlers now that these are created.
             self._event_manager.assign_manager_to_request_type(
@@ -330,6 +334,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def UserManager(cls) -> UserManager:
         return GriptapeNodes.get_instance()._user_manager
 
+    @classmethod
+    def ProjectManager(cls) -> ProjectManager:
+        return GriptapeNodes.get_instance()._project_manager
+
     @classmethod
     def clear_data(cls) -> None:
         # Get canvas

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -7,11 +7,11 @@ import uuid
 from typing import TYPE_CHECKING, ClassVar
 
 from attrs import define, field
-from griptape.artifacts import ErrorArtifact, ImageUrlArtifact, JsonArtifact
+from griptape.artifacts import ErrorArtifact, ImageUrlArtifact
 from griptape.drivers.image_generation import BaseImageGenerationDriver
 from griptape.drivers.image_generation.griptape_cloud import GriptapeCloudImageGenerationDriver
 from griptape.drivers.prompt.griptape_cloud import GriptapeCloudPromptDriver
-from griptape.events import FinishTaskEvent, TextChunkEvent
+from griptape.events import TextChunkEvent
 from griptape.loaders import ImageLoader
 from griptape.memory.structure import ConversationMemory
 from griptape.rules import Rule, Ruleset
@@ -20,6 +20,7 @@ from griptape.tools import BaseImageGenerationTool
 from griptape.tools.mcp.tool import MCPTool
 from griptape.utils.decorators import activity
 from json_repair import repair_json
+from pydantic import create_model
 from schema import Literal, Schema
 
 from griptape_nodes.retained_mode.events.agent_events import (
@@ -35,7 +36,6 @@ from griptape_nodes.retained_mode.events.agent_events import (
     ResetAgentConversationMemoryResultSuccess,
     RunAgentRequest,
     RunAgentResultFailure,
-    RunAgentResultStarted,
     RunAgentResultSuccess,
 )
 from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
@@ -202,15 +202,17 @@ class AgentManager:
             self.image_tool = self._initialize_image_tool()
         if self.mcp_tool is None:
             self.mcp_tool = self._initialize_mcp_tool()
-        await asyncio.to_thread(self._on_handle_run_agent_request, request)
-        return RunAgentResultStarted(result_details="Agent execution started successfully.")
+        try:
+            return await asyncio.to_thread(self._on_handle_run_agent_request, request)
+        except Exception as e:
+            err_msg = f"Error handling run agent request: {e}"
+            return RunAgentResultFailure(error=ErrorArtifact(e).to_dict(), result_details=err_msg)
 
     def _create_agent(self, additional_mcp_servers: list[str] | None = None) -> Agent:
-        output_schema = Schema(
-            {
-                "conversation_output": str,
-                "generated_image_urls": [str],
-            }
+        output_schema = create_model(
+            "AgentOutputSchema",
+            conversation_output=(str, ...),
+            generated_image_urls=(list[str], ...),
         )
 
         tools = []
@@ -252,7 +254,6 @@ class AgentManager:
             event_stream = agent.run_stream([request.input, *artifacts])
             full_result = ""
             last_conversation_output = ""
-            last_event = None
             for event in event_stream:
                 if isinstance(event, TextChunkEvent):
                     full_result += event.token
@@ -274,19 +275,12 @@ class AgentManager:
                                 last_conversation_output = new_conversation_output
                     except json.JSONDecodeError:
                         pass  # Ignore incomplete JSON
-                last_event = event
-            if isinstance(last_event, FinishTaskEvent):
-                if isinstance(last_event.task_output, ErrorArtifact):
-                    return RunAgentResultFailure(
-                        error=last_event.task_output.to_dict(), result_details=last_event.task_output.to_json()
-                    )
-                if isinstance(last_event.task_output, JsonArtifact):
-                    return RunAgentResultSuccess(
-                        last_event.task_output.to_dict(), result_details="Agent execution completed successfully."
-                    )
-            err_msg = f"Unexpected final event: {last_event}"
-            logger.error(err_msg)
-            return RunAgentResultFailure(error=ErrorArtifact(last_event).to_dict(), result_details=err_msg)
+            if isinstance(agent.output, ErrorArtifact):
+                return RunAgentResultFailure(error=agent.output.to_dict(), result_details=agent.output.to_json())
+
+            return RunAgentResultSuccess(
+                agent.output.to_dict(), result_details="Agent execution completed successfully."
+            )
         except Exception as e:
             err_msg = f"Error running agent: {e}"
             logger.exception(err_msg)

griptape_nodes/retained_mode/managers/event_manager.py

@@ -7,6 +7,7 @@ from collections import defaultdict
 from dataclasses import fields
 from typing import TYPE_CHECKING, Any, cast
 
+from asyncio_thread_runner import ThreadRunner
 from typing_extensions import TypedDict, TypeVar
 
 from griptape_nodes.retained_mode.events.base_events import (
@@ -276,8 +277,8 @@ class EventManager:
         if inspect.iscoroutinefunction(callback):
             try:
                 asyncio.get_running_loop()
-                msg = "Async handler cannot be called with sync handle_request. Use ahandle_request instead."
-                raise ValueError(msg)
+                with ThreadRunner() as runner:
+                    result_payload: ResultPayload = runner.run(callback(request))
             except RuntimeError:
                 # No event loop running, safe to use asyncio.run
                 result_payload: ResultPayload = asyncio.run(callback(request))
@@ -317,10 +318,6 @@ class EventManager:
         if app_event_type in self._app_event_listeners:
             listener_set = self._app_event_listeners[app_event_type]
 
-            await asyncio.gather(
-                *[
-                    asyncio.create_task(call_function(listener_callback, app_event))
-                    for listener_callback in listener_set
-                ],
-                return_exceptions=True,
-            )
+            async with asyncio.TaskGroup() as tg:
+                for listener_callback in listener_set:
+                    tg.create_task(call_function(listener_callback, app_event))