griptape-nodes 0.52.1__py3-none-any.whl → 0.54.0__py3-none-any.whl

griptape_nodes/retained_mode/griptape_nodes.py

@@ -37,6 +37,7 @@ from griptape_nodes.retained_mode.events.app_events import (
 )
 from griptape_nodes.retained_mode.events.base_events import (
     GriptapeNodeEvent,
+    ResultDetails,
     ResultPayloadFailure,
 )
 from griptape_nodes.retained_mode.events.flow_events import (
@@ -61,6 +62,7 @@ if TYPE_CHECKING:
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
     from griptape_nodes.retained_mode.managers.flow_manager import FlowManager
     from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
+    from griptape_nodes.retained_mode.managers.model_manager import ModelManager
     from griptape_nodes.retained_mode.managers.node_manager import NodeManager
     from griptape_nodes.retained_mode.managers.object_manager import ObjectManager
     from griptape_nodes.retained_mode.managers.operation_manager import (
@@ -137,6 +139,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _flow_manager: FlowManager
     _context_manager: ContextManager
     _library_manager: LibraryManager
+    _model_manager: ModelManager
     _workflow_manager: WorkflowManager
     _workflow_variables_manager: VariablesManager
     _arbitrary_code_exec_manager: ArbitraryCodeExecManager
@@ -159,6 +162,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
         from griptape_nodes.retained_mode.managers.event_manager import EventManager
         from griptape_nodes.retained_mode.managers.flow_manager import FlowManager
         from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
+        from griptape_nodes.retained_mode.managers.model_manager import ModelManager
         from griptape_nodes.retained_mode.managers.node_manager import NodeManager
         from griptape_nodes.retained_mode.managers.object_manager import ObjectManager
         from griptape_nodes.retained_mode.managers.operation_manager import (
@@ -192,6 +196,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._flow_manager = FlowManager(self._event_manager)
             self._context_manager = ContextManager(self._event_manager)
             self._library_manager = LibraryManager(self._event_manager)
+            self._model_manager = ModelManager(self._event_manager)
             self._workflow_manager = WorkflowManager(self._event_manager)
             self._workflow_variables_manager = VariablesManager(self._event_manager)
             self._arbitrary_code_exec_manager = ArbitraryCodeExecManager(self._event_manager)
@@ -252,7 +257,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 type(request).__name__,
                 request,
             )
-            return ResultPayloadFailure(exception=e)
+            return ResultPayloadFailure(
+                exception=e, result_details=f"Unhandled exception while processing {type(request).__name__}: {e}"
+            )
         else:
             return result_event.result
 
@@ -276,7 +283,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 type(request).__name__,
                 request,
             )
-            return ResultPayloadFailure(exception=e)
+            return ResultPayloadFailure(
+                exception=e, result_details=f"Unhandled exception while processing async {type(request).__name__}: {e}"
+            )
         else:
             return result_event.result
 
@@ -301,6 +310,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def LibraryManager(cls) -> LibraryManager:
         return GriptapeNodes.get_instance()._library_manager
 
+    @classmethod
+    def ModelManager(cls) -> ModelManager:
+        return GriptapeNodes.get_instance()._model_manager
+
     @classmethod
     def ObjectManager(cls) -> ObjectManager:
         return GriptapeNodes.get_instance()._object_manager
@@ -421,6 +434,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
                     major=engine_ver.major,
                     minor=engine_ver.minor,
                     patch=engine_ver.patch,
+                    result_details="Engine version retrieved successfully.",
                 )
             details = f"Attempted to get engine version. Failed because version string '{engine_ver}' wasn't in expected major.minor.patch format."
             logger.error(details)
@@ -447,7 +461,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
         await subscribe_to_topic(topic)
         logger.info("Subscribed to new session topic: %s", topic)
 
-        return AppStartSessionResultSuccess(current_session_id)
+        return AppStartSessionResultSuccess(current_session_id, result_details="Session started successfully.")
 
     async def handle_session_end_request(self, _: AppEndSessionRequest) -> ResultPayload:
         from griptape_nodes.app.app import unsubscribe_from_topic
@@ -465,14 +479,19 @@ class GriptapeNodes(metaclass=SingletonMeta):
             unsubscribe_topic = f"sessions/{previous_session_id}/request"
             await unsubscribe_from_topic(unsubscribe_topic)
 
-            return AppEndSessionResultSuccess(session_id=previous_session_id)
+            return AppEndSessionResultSuccess(
+                session_id=previous_session_id, result_details="Session ended successfully."
+            )
         except Exception as err:
             details = f"Failed to end session due to '{err}'."
             logger.error(details)
             return AppEndSessionResultFailure(result_details=details)
 
     def handle_get_session_request(self, _: AppGetSessionRequest) -> ResultPayload:
-        return AppGetSessionResultSuccess(session_id=GriptapeNodes.SessionManager().get_active_session_id())
+        return AppGetSessionResultSuccess(
+            session_id=GriptapeNodes.SessionManager().get_active_session_id(),
+            result_details="Session ID retrieved successfully.",
+        )
 
     def handle_session_heartbeat_request(self, request: SessionHeartbeatRequest) -> ResultPayload:  # noqa: ARG002
         """Handle session heartbeat requests.
@@ -487,8 +506,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 return SessionHeartbeatResultFailure(result_details=details)
 
             details = f"Session heartbeat successful for session: {active_session_id}"
-            logger.debug(details)
-            return SessionHeartbeatResultSuccess()
+            return SessionHeartbeatResultSuccess(result_details=details)
         except Exception as err:
             details = f"Failed to handle session heartbeat: {err}"
             logger.error(details)
@@ -509,7 +527,6 @@ class GriptapeNodes(metaclass=SingletonMeta):
             # Get engine name
             engine_name = GriptapeNodes.EngineIdentityManager().get_engine_name()
 
-            logger.debug("Engine heartbeat successful")
             return EngineHeartbeatResultSuccess(
                 heartbeat_id=request.heartbeat_id,
                 engine_version=engine_version,
@@ -517,6 +534,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 engine_id=GriptapeNodes.EngineIdentityManager().get_active_engine_id(),
                 session_id=GriptapeNodes.SessionManager().get_active_session_id(),
                 timestamp=datetime.now(tz=UTC).isoformat(),
+                result_details="Engine heartbeat successful",
                 **instance_info,
                 **workflow_info,
             )
@@ -529,8 +547,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
         """Handle requests to get the current engine name."""
         try:
             engine_name = GriptapeNodes.EngineIdentityManager().get_engine_name()
-            logger.debug("Retrieved engine name: %s", engine_name)
-            return GetEngineNameResultSuccess(engine_name=engine_name)
+            return GetEngineNameResultSuccess(
+                engine_name=engine_name, result_details="Engine name retrieved successfully."
+            )
         except Exception as err:
             error_message = f"Failed to get engine name: {err}"
             logger.error(error_message)
@@ -547,8 +566,11 @@ class GriptapeNodes(metaclass=SingletonMeta):
 
             # Set the new engine name
             GriptapeNodes.EngineIdentityManager().set_engine_name(request.engine_name.strip())
-            logger.info("Engine name set to: %s", request.engine_name.strip())
-            return SetEngineNameResultSuccess(engine_name=request.engine_name.strip())
+            details = f"Engine name set to: {request.engine_name.strip()}"
+            return SetEngineNameResultSuccess(
+                engine_name=request.engine_name.strip(),
+                result_details=ResultDetails(message=details, level=logging.INFO),
+            )
 
         except Exception as err:
             error_message = f"Failed to set engine name: {err}"

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import logging
 import os
+import threading
 import uuid
 from typing import TYPE_CHECKING
 
@@ -37,6 +38,7 @@ from griptape_nodes.retained_mode.events.agent_events import (
     RunAgentResultStarted,
     RunAgentResultSuccess,
 )
+from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent, ResultPayload
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
@@ -45,6 +47,7 @@ from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
 from griptape_nodes.retained_mode.managers.static_files_manager import (
     StaticFilesManager,
 )
+from griptape_nodes.servers.mcp import start_mcp_server
 
 if TYPE_CHECKING:
     from griptape.tools.mcp.sessions import StreamableHttpConnection
@@ -104,6 +107,11 @@ class AgentManager:
             event_manager.assign_manager_to_request_type(
                 GetConversationMemoryRequest, self.on_handle_get_conversation_memory_request
             )
+            event_manager.add_listener_to_app_event(
+                AppInitializationComplete,
+                self.on_app_initialization_complete,
+            )
+            # TODO: Listen for shutdown event (https://github.com/griptape-ai/griptape-nodes/issues/2149) to stop mcp server
 
     def _initialize_prompt_driver(self) -> GriptapeCloudPromptDriver:
         api_key = secrets_manager.get_secret(API_KEY_ENV_VAR)
@@ -137,7 +145,7 @@ class AgentManager:
         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()
+        return RunAgentResultStarted(result_details="Agent execution started successfully.")
 
     def _create_agent(self) -> Agent:
         output_schema = Schema(
@@ -207,7 +215,9 @@ class AgentManager:
                         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())
+                    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)
@@ -226,7 +236,7 @@ class AgentManager:
             details = f"Error configuring agent: {e}"
             logger.error(details)
             return ConfigureAgentResultFailure(result_details=details)
-        return ConfigureAgentResultSuccess()
+        return ConfigureAgentResultSuccess(result_details="Agent configured successfully.")
 
     def on_handle_reset_agent_conversation_memory_request(
         self, _: ResetAgentConversationMemoryRequest
@@ -237,7 +247,7 @@ class AgentManager:
             details = f"Error resetting agent conversation memory: {e}"
             logger.error(details)
             return ResetAgentConversationMemoryResultFailure(result_details=details)
-        return ResetAgentConversationMemoryResultSuccess()
+        return ResetAgentConversationMemoryResultSuccess(result_details="Agent conversation memory reset successfully.")
 
     def on_handle_get_conversation_memory_request(self, _: GetConversationMemoryRequest) -> ResultPayload:
         try:
@@ -246,4 +256,12 @@ class AgentManager:
             details = f"Error getting conversation memory: {e}"
             logger.error(details)
             return GetConversationMemoryResultFailure(result_details=details)
-        return GetConversationMemoryResultSuccess(runs=conversation_memory)
+        return GetConversationMemoryResultSuccess(
+            runs=conversation_memory, result_details="Conversation memory retrieved successfully."
+        )
+
+    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
+        secrets_manager = GriptapeNodes.SecretsManager()
+        api_key = secrets_manager.get_secret("GT_CLOUD_API_KEY")
+        # Start MCP server in daemon thread
+        threading.Thread(target=start_mcp_server, args=(api_key,), daemon=True, name="mcp-server").start()

griptape_nodes/retained_mode/managers/arbitrary_code_exec_manager.py

@@ -43,7 +43,9 @@ class ArbitraryCodeExecManager:
                 python_output = exec(request.python_string)  # noqa: S102
 
             captured_output = strip_ansi_codes(string_buffer.getvalue())
-            result = RunArbitraryPythonStringResultSuccess(python_output=captured_output)
+            result = RunArbitraryPythonStringResultSuccess(
+                python_output=captured_output, result_details="Successfully executed Python string"
+            )
         except Exception as e:
             python_output = f"ERROR: {e}"
             result = RunArbitraryPythonStringResultFailure(python_output=python_output, result_details=python_output)

griptape_nodes/retained_mode/managers/config_manager.py

@@ -8,16 +8,18 @@ from typing import Any, Literal
 from pydantic import ValidationError
 from xdg_base_dirs import xdg_config_home
 
+from griptape_nodes.node_library.library_registry import LibraryRegistry
 from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
-from griptape_nodes.retained_mode.events.base_events import (
-    ResultPayload,
-)
+from griptape_nodes.retained_mode.events.base_events import ResultPayload
 from griptape_nodes.retained_mode.events.config_events import (
     GetConfigCategoryRequest,
     GetConfigCategoryResultFailure,
     GetConfigCategoryResultSuccess,
     GetConfigPathRequest,
     GetConfigPathResultSuccess,
+    GetConfigSchemaRequest,
+    GetConfigSchemaResultFailure,
+    GetConfigSchemaResultSuccess,
     GetConfigValueRequest,
     GetConfigValueResultFailure,
     GetConfigValueResultSuccess,
@@ -84,6 +86,9 @@ class ConfigManager:
             event_manager.assign_manager_to_request_type(GetConfigValueRequest, self.on_handle_get_config_value_request)
             event_manager.assign_manager_to_request_type(SetConfigValueRequest, self.on_handle_set_config_value_request)
             event_manager.assign_manager_to_request_type(GetConfigPathRequest, self.on_handle_get_config_path_request)
+            event_manager.assign_manager_to_request_type(
+                GetConfigSchemaRequest, self.on_handle_get_config_schema_request
+            )
             event_manager.assign_manager_to_request_type(ResetConfigRequest, self.on_handle_reset_config_request)
 
             event_manager.add_listener_to_app_event(
@@ -194,6 +199,9 @@ class ConfigManager:
             merged_config = merge_dicts(merged_config, self.env_config)
             logger.debug("Merged config from environment variables: %s", list(self.env_config.keys()))
 
+        # Re-assign workspace path in case env var overrides it
+        self.workspace_path = merged_config["workspace_directory"]
+
         # Validate the full config against the Settings model.
         try:
             Settings.model_validate(merged_config)
@@ -412,6 +420,39 @@ class ConfigManager:
         result_details = "Successfully returned the config path."
         return GetConfigPathResultSuccess(config_path=str(USER_CONFIG_PATH), result_details=result_details)
 
+    def on_handle_get_config_schema_request(self, request: GetConfigSchemaRequest) -> ResultPayload:  # noqa: ARG002
+        """Handle request to get the configuration schema with current values and library settings.
+
+        This method returns a clean structure with three main components:
+        1. base_schema: Core settings schema from Pydantic Settings model with categories
+        2. library_schemas: Library-specific schemas from definition files (preserves enums)
+        3. current_values: All current configuration values from merged config
+
+        The approach separates concerns for frontend flexibility and simplicity.
+        Library settings with explicit schemas (including enums) are preserved, while
+        libraries without schemas get simple object types.
+        """
+        try:
+            # Get base settings schema and current values
+            base_schema = Settings.model_json_schema()
+            current_values = self.merged_config.copy()
+
+            # Get library schemas
+            library_schemas = LibraryRegistry.get_all_library_schemas()
+
+            # Return clean structure
+            schema_with_defaults = {
+                "base_schema": base_schema,
+                "library_schemas": library_schemas,
+                "current_values": current_values,
+            }
+
+            result_details = "Successfully returned the configuration schema with default values and library settings."
+            return GetConfigSchemaResultSuccess(schema=schema_with_defaults, result_details=result_details)
+        except Exception as e:
+            result_details = f"Failed to generate configuration schema: {e}"
+            return GetConfigSchemaResultFailure(result_details=result_details)
+
     def on_handle_reset_config_request(self, request: ResetConfigRequest) -> ResultPayload:  # noqa: ARG002
         try:
             self.reset_user_config()

griptape_nodes/retained_mode/managers/context_manager.py

@@ -279,19 +279,20 @@ class ContextManager:
         # As of today, we only allow a single Workflow context at a time. This may change in the future.
         if self.has_current_workflow():
             msg = f"Attempted to set the Workflow '{request.workflow_name}' as the Current Context. Failed because an existing workflow, '{self.get_current_workflow_name()}', is already in the Current Context. In order to clear the existing workflow and remove all objects and references to it, issue a ClearAllObjectState request."
-            logger.error(msg)
-            return SetWorkflowContextFailure()
+            return SetWorkflowContextFailure(result_details=msg)
 
         self.push_workflow(request.workflow_name)
         msg = f"Successfully set the Workflow '{request.workflow_name}' as the Current Context."
-        logger.debug(msg)
-        return SetWorkflowContextSuccess()
+        return SetWorkflowContextSuccess(result_details=msg)
 
     def on_get_workflow_context_request(self, request: GetWorkflowContextRequest) -> ResultPayload:  # noqa: ARG002
         workflow_name = None
         if self.has_current_workflow():
             workflow_name = self.get_current_workflow_name()
-        return GetWorkflowContextSuccess(workflow_name=workflow_name)
+        return GetWorkflowContextSuccess(
+            workflow_name=workflow_name,
+            result_details=f"Successfully retrieved workflow context: {workflow_name or 'None'}",
+        )
 
     def workflow(self, workflow_name: str) -> ContextManager.WorkflowContext:
         """Create a context manager for a Workflow context.

griptape_nodes/retained_mode/managers/event_manager.py

@@ -294,5 +294,11 @@ class EventManager:
         app_event_type = type(app_event)
         if app_event_type in self._app_event_listeners:
             listener_set = self._app_event_listeners[app_event_type]
-            for listener_callback in listener_set:
-                await call_function(listener_callback, app_event)
+
+            await asyncio.gather(
+                *[
+                    asyncio.create_task(call_function(listener_callback, app_event))
+                    for listener_callback in listener_set
+                ],
+                return_exceptions=True,
+            )