griptape-nodes 0.57.1__py3-none-any.whl → 0.58.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/session_manager.py

@@ -6,323 +6,360 @@ Supports multiple concurrent sessions per engine with one active session managed
 Storage structure: ~/.local/state/griptape_nodes/engines/{engine_id}/sessions.json
 """
 
+from __future__ import annotations
+
 import json
 import logging
+import uuid
 from datetime import UTC, datetime
-from pathlib import Path
+from typing import TYPE_CHECKING
 
+from pydantic import BaseModel
 from xdg_base_dirs import xdg_state_home
 
-from griptape_nodes.retained_mode.events.base_events import BaseEvent
-from griptape_nodes.retained_mode.managers.event_manager import EventManager
+from griptape_nodes.retained_mode.events.app_events import (
+    AppEndSessionRequest,
+    AppEndSessionResultFailure,
+    AppEndSessionResultSuccess,
+    AppGetSessionRequest,
+    AppGetSessionResultSuccess,
+    AppStartSessionRequest,
+    AppStartSessionResultSuccess,
+    SessionHeartbeatRequest,
+    SessionHeartbeatResultFailure,
+    SessionHeartbeatResultSuccess,
+)
+from griptape_nodes.retained_mode.events.base_events import BaseEvent, ResultPayload
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from griptape_nodes.retained_mode.managers.engine_identity_manager import EngineIdentityManager
+    from griptape_nodes.retained_mode.managers.event_manager import EventManager
 
 logger = logging.getLogger("griptape_nodes")
 
 
+class SessionData(BaseModel):
+    """Represents a single session's data."""
+
+    session_id: str
+    engine_id: str | None = None
+    started_at: str
+    last_updated: str
+
+
+class SessionsStorage(BaseModel):
+    """Represents the sessions storage structure."""
+
+    sessions: list[SessionData]
+
+
 class SessionManager:
     """Manages session saving and active session state."""
 
-    _active_session_id: str | None = None
-
     _SESSION_STATE_FILE = "sessions.json"
 
-    def __init__(self, event_manager: EventManager | None = None) -> None:
+    def __init__(
+        self,
+        engine_identity_manager: EngineIdentityManager,
+        event_manager: EventManager | None = None,
+    ) -> None:
         """Initialize the SessionManager.
 
         Args:
+            engine_identity_manager: The EngineIdentityManager instance to use for engine ID operations.
             event_manager: The EventManager instance to use for event handling.
         """
+        self._engine_identity_manager = engine_identity_manager
+        self._sessions_data = self._load_sessions_data()
+        self._active_session_id = self._get_or_initialize_active_session()
         BaseEvent._session_id = self._active_session_id
         if event_manager is not None:
-            # Register event handlers here when session events are defined
-            pass
+            event_manager.assign_manager_to_request_type(AppStartSessionRequest, self.handle_session_start_request)
+            event_manager.assign_manager_to_request_type(AppEndSessionRequest, self.handle_session_end_request)
+            event_manager.assign_manager_to_request_type(AppGetSessionRequest, self.handle_get_session_request)
+            event_manager.assign_manager_to_request_type(SessionHeartbeatRequest, self.handle_session_heartbeat_request)
 
-    @classmethod
-    def _get_session_state_dir(cls, engine_id: str | None = None) -> Path:
-        """Get the XDG state directory for session storage.
+    @property
+    def active_session_id(self) -> str | None:
+        """Get the active session ID.
 
-        Args:
-            engine_id: Optional engine ID to create engine-specific directory
+        Returns:
+            str | None: The active session ID or None if not set
         """
-        base_dir = xdg_state_home() / "griptape_nodes"
-        if engine_id:
-            return base_dir / "engines" / engine_id
-        return base_dir
+        return self._active_session_id
 
-    @classmethod
-    def _get_session_state_file(cls, engine_id: str | None = None) -> Path:
-        """Get the path to the session state storage file.
+    @active_session_id.setter
+    def active_session_id(self, session_id: str) -> None:
+        """Set the active session ID.
 
         Args:
-            engine_id: Optional engine ID to get engine-specific session file
+            session_id: The session ID to set as active
         """
-        return cls._get_session_state_dir(engine_id) / cls._SESSION_STATE_FILE
-
-    @classmethod
-    def _load_sessions_data(cls, engine_id: str | None = None) -> dict:
-        """Load sessions data from storage.
+        self._active_session_id = session_id
+        BaseEvent._session_id = session_id
+        logger.debug("Set active session ID to: %s", session_id)
 
-        Args:
-            engine_id: Optional engine ID to load engine-specific sessions
+    @property
+    def all_sessions(self) -> list[SessionData]:
+        """Get all registered sessions for the current engine.
 
         Returns:
-            dict: Sessions data structure with sessions array
+            list[SessionData]: List of all session data for the current engine
         """
-        session_state_file = cls._get_session_state_file(engine_id)
+        return self._sessions_data.sessions
 
-        if session_state_file.exists():
-            try:
-                with session_state_file.open("r") as f:
-                    data = json.load(f)
-                    if isinstance(data, dict) and "sessions" in data:
-                        return {"sessions": data["sessions"]}
-            except (json.JSONDecodeError, OSError):
-                pass
+    def save_session(self, session_id: str) -> None:
+        """Save a session and make it the active session.
 
-        return {"sessions": []}
+        Args:
+            session_id: The session ID to save
+        """
+        engine_id = self._get_current_engine_id()
+        session_data = SessionData(
+            session_id=session_id,
+            engine_id=engine_id,
+            started_at=datetime.now(tz=UTC).isoformat(),
+            last_updated=datetime.now(tz=UTC).isoformat(),
+        )
 
-    @classmethod
-    def _save_sessions_data(cls, sessions_data: dict, engine_id: str | None = None) -> None:
-        """Save sessions data to storage.
+        # Add or update the session
+        self._add_or_update_session(session_data)
+
+        # Set as active session
+        self._active_session_id = session_id
+        BaseEvent._session_id = session_id
+        logger.info("Saved and activated session: %s for engine: %s", session_id, engine_id)
+
+    def remove_session(self, session_id: str) -> None:
+        """Remove a session from the sessions data for the current engine.
 
         Args:
-            sessions_data: Sessions data structure to save
-            engine_id: Optional engine ID to save engine-specific sessions
+            session_id: The session ID to remove
         """
-        session_state_dir = cls._get_session_state_dir(engine_id)
-        session_state_dir.mkdir(parents=True, exist_ok=True)
+        engine_id = self._get_current_engine_id()
 
-        session_state_file = cls._get_session_state_file(engine_id)
-        with session_state_file.open("w") as f:
-            json.dump(sessions_data, f, indent=2)
+        # Remove the session
+        self._sessions_data.sessions = [
+            session for session in self._sessions_data.sessions if session.session_id != session_id
+        ]
 
-    @classmethod
-    def _get_current_engine_id(cls) -> str | None:
-        """Get the current engine ID from EngineIdentityManager.
+        # Clear active session if it was the removed session
+        if self._active_session_id == session_id:
+            # Set to first remaining session or None
+            self._active_session_id = (
+                self._sessions_data.sessions[0].session_id if self._sessions_data.sessions else None
+            )
+            BaseEvent._session_id = self._active_session_id
+            logger.info(
+                "Removed active session %s for engine %s, set new active session to: %s",
+                session_id,
+                engine_id,
+                self._active_session_id,
+            )
 
-        Returns:
-            str | None: The current engine ID or None if not set
-        """
-        # Import here to avoid circular imports
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+        self._save_sessions_data(self._sessions_data, engine_id)
+        logger.info("Removed session: %s from engine: %s", session_id, engine_id)
 
-        return GriptapeNodes.EngineIdentityManager().get_active_engine_id()
+    def clear_saved_session(self) -> None:
+        """Clear all saved session data for the current engine."""
+        # Clear active session
+        self._active_session_id = None
+        BaseEvent._session_id = None
 
-    @classmethod
-    def _find_session_by_id(cls, sessions_data: dict, session_id: str) -> dict | None:
-        """Find a session by ID in the sessions data.
+        # Clear in-memory session data
+        self._sessions_data = SessionsStorage(sessions=[])
 
-        Args:
-            sessions_data: The sessions data structure
-            session_id: The session ID to find
+        engine_id = self._get_current_engine_id()
+        session_state_file = self._get_session_state_file(engine_id)
+        if session_state_file.exists():
+            try:
+                session_state_file.unlink()
+                logger.info("Cleared all saved session data for engine: %s", engine_id)
+            except OSError:
+                # If we can't delete the file, just clear its contents
+                self._save_sessions_data(self._sessions_data, engine_id)
+                logger.warning("Could not delete session file for engine %s, cleared contents instead", engine_id)
+
+    def _get_or_initialize_active_session(self) -> str | None:
+        """Get or initialize the active session ID.
+
+        Falls back to first available session if no active session is set.
 
         Returns:
-            dict | None: The session data if found, None otherwise
+            str | None: The active session ID or None if no sessions exist
         """
-        for session in sessions_data.get("sessions", []):
-            if session.get("session_id") == session_id:
-                return session
+        # Fall back to first session if available
+        if self._sessions_data.sessions:
+            first_session = self._sessions_data.sessions[0]
+            logger.debug(
+                "Initialized active session to first saved session: %s for engine: %s",
+                first_session.session_id,
+                first_session.engine_id,
+            )
+            return first_session.session_id
+
         return None
 
-    @classmethod
-    def _add_or_update_session(cls, session_data: dict) -> None:
+    def _add_or_update_session(self, session_data: SessionData) -> None:
         """Add or update a session in the sessions data structure.
 
         Args:
             session_data: The session data to add or update
         """
-        engine_id = cls._get_current_engine_id()
-        sessions_data = cls._load_sessions_data(engine_id)
+        engine_id = self._get_current_engine_id()
 
         # Find existing session
-        session_id = session_data["session_id"]
-        existing_session = cls._find_session_by_id(sessions_data, session_id)
+        existing_session = self._find_session_by_id(self._sessions_data, session_data.session_id)
 
         if existing_session:
             # Update existing session
-            existing_session.update(session_data)
-            existing_session["last_updated"] = datetime.now(tz=UTC).isoformat()
+            existing_session.session_id = session_data.session_id
+            existing_session.engine_id = session_data.engine_id
+            existing_session.started_at = session_data.started_at
+            existing_session.last_updated = datetime.now(tz=UTC).isoformat()
         else:
             # Add new session
-            session_data["engine_id"] = engine_id
-            sessions_data.setdefault("sessions", []).append(session_data)
+            self._sessions_data.sessions.append(session_data)
 
-        cls._save_sessions_data(sessions_data, engine_id)
+        self._save_sessions_data(self._sessions_data, engine_id)
 
-    @classmethod
-    def get_active_session_id(cls) -> str | None:
-        """Get the active session ID.
+    def _get_current_engine_id(self) -> str | None:
+        """Get the current engine ID from EngineIdentityManager.
 
         Returns:
-            str | None: The active session ID or None if not set
-        """
-        return cls._active_session_id
-
-    @classmethod
-    def set_active_session_id(cls, session_id: str) -> None:
-        """Set the active session ID.
-
-        Args:
-            session_id: The session ID to set as active
-
-        Raises:
-            ValueError: If session_id is not found in persisted sessions
-        """
-        engine_id = cls._get_current_engine_id()
-        sessions_data = cls._load_sessions_data(engine_id)
-
-        # Verify the session exists
-        if cls._find_session_by_id(sessions_data, session_id):
-            cls._active_session_id = session_id
-            logger.debug("Set active session ID to: %s", session_id)
-        else:
-            msg = f"Session with ID {session_id} not found for engine {engine_id}"
-            raise ValueError(msg)
-
-    @classmethod
-    def save_session(cls, session_id: str) -> None:
-        """Save a session and make it the active session.
-
-        Args:
-            session_id: The session ID to save
+            str | None: The current engine ID or None if not set
         """
-        engine_id = cls._get_current_engine_id()
-        session_data = {
-            "session_id": session_id,
-            "engine_id": engine_id,
-            "started_at": datetime.now(tz=UTC).isoformat(),
-            "last_updated": datetime.now(tz=UTC).isoformat(),
-        }
-
-        # Add or update the session
-        cls._add_or_update_session(session_data)
-
-        # Set as active session
-        cls._active_session_id = session_id
-        BaseEvent._session_id = session_id
-        logger.info("Saved and activated session: %s for engine: %s", session_id, engine_id)
+        return self._engine_identity_manager.active_engine_id
 
-    @classmethod
-    def get_saved_session_id(cls) -> str | None:
-        """Get the active session ID if it exists.
+    def _load_sessions_data(self) -> SessionsStorage:
+        """Load sessions data from storage.
 
         Returns:
-            str | None: The active session ID or None if no active session
+            SessionsStorage: Sessions data structure with sessions array
         """
-        # Return active session if set
-        if cls._active_session_id:
-            return cls._active_session_id
-
-        # Fall back to first session if available
-        engine_id = cls._get_current_engine_id()
-        sessions_data = cls._load_sessions_data(engine_id)
-        sessions = sessions_data.get("sessions", [])
-        if sessions:
-            first_session_id = sessions[0].get("session_id")
-            # Set as active for future calls
-            BaseEvent._session_id = first_session_id
-            cls._active_session_id = first_session_id
-            logger.debug("Retrieved first saved session as active: %s for engine: %s", first_session_id, engine_id)
-            return first_session_id
-
-        return None
+        engine_id = self._get_current_engine_id()
+        session_state_file = self._get_session_state_file(engine_id)
 
-    @classmethod
-    def clear_saved_session(cls) -> None:
-        """Clear all saved session data for the current engine."""
-        # Clear active session
-        cls._active_session_id = None
-        BaseEvent._session_id = None
-
-        engine_id = cls._get_current_engine_id()
-        session_state_file = cls._get_session_state_file(engine_id)
         if session_state_file.exists():
             try:
-                session_state_file.unlink()
-                logger.info("Cleared all saved session data for engine: %s", engine_id)
-            except OSError:
-                # If we can't delete the file, just clear its contents
-                cls._save_sessions_data({"sessions": []}, engine_id)
-                logger.warning("Could not delete session file for engine %s, cleared contents instead", engine_id)
-
-    @classmethod
-    def has_saved_session(cls) -> bool:
-        """Check if there is a saved session.
-
-        Returns:
-            bool: True if there is a saved session, False otherwise
-        """
-        return cls.get_saved_session_id() is not None
-
-    @classmethod
-    def get_all_sessions(cls) -> list[dict]:
-        """Get all registered sessions for the current engine.
+                with session_state_file.open("r") as f:
+                    data = json.load(f)
+                    if isinstance(data, dict) and "sessions" in data:
+                        return SessionsStorage.model_validate(data)
+            except (json.JSONDecodeError, OSError):
+                pass
 
-        Returns:
-            list[dict]: List of all session data for the current engine
-        """
-        engine_id = cls._get_current_engine_id()
-        sessions_data = cls._load_sessions_data(engine_id)
-        return sessions_data.get("sessions", [])
+        return SessionsStorage(sessions=[])
 
-    @classmethod
-    def remove_session(cls, session_id: str) -> None:
-        """Remove a session from the sessions data for the current engine.
+    def _save_sessions_data(self, sessions_data: SessionsStorage, engine_id: str | None = None) -> None:
+        """Save sessions data to storage.
 
         Args:
-            session_id: The session ID to remove
+            sessions_data: Sessions data structure to save
+            engine_id: Optional engine ID to save engine-specific sessions
         """
-        engine_id = cls._get_current_engine_id()
-        sessions_data = cls._load_sessions_data(engine_id)
-
-        # Remove the session
-        sessions_data["sessions"] = [
-            session for session in sessions_data.get("sessions", []) if session.get("session_id") != session_id
-        ]
+        session_state_dir = self._get_session_state_dir(engine_id)
+        session_state_dir.mkdir(parents=True, exist_ok=True)
 
-        # Clear active session if it was the removed session
-        if cls._active_session_id == session_id:
-            # Set to first remaining session or None
-            remaining_sessions = sessions_data.get("sessions", [])
-            cls._active_session_id = remaining_sessions[0].get("session_id") if remaining_sessions else None
-            logger.info(
-                "Removed active session %s for engine %s, set new active session to: %s",
-                session_id,
-                engine_id,
-                cls._active_session_id,
+        session_state_file = self._get_session_state_file(engine_id)
+        with session_state_file.open("w") as f:
+            json.dump(sessions_data.model_dump(exclude_none=True), f, indent=2)
+
+        # Update in-memory copy
+        self._sessions_data = sessions_data
+
+    async def handle_session_start_request(self, request: AppStartSessionRequest) -> ResultPayload:  # noqa: ARG002
+        current_session_id = self.active_session_id
+        if current_session_id is None:
+            # Client wants a new session
+            current_session_id = uuid.uuid4().hex
+            self.save_session(current_session_id)
+            details = f"New session '{current_session_id}' started at {datetime.now(tz=UTC)}."
+            logger.info(details)
+        else:
+            details = f"Session '{current_session_id}' already active. Joining..."
+
+        return AppStartSessionResultSuccess(current_session_id, result_details="Session started successfully.")
+
+    async def handle_session_end_request(self, _: AppEndSessionRequest) -> ResultPayload:
+        try:
+            previous_session_id = self.active_session_id
+            if previous_session_id is None:
+                details = "No active session to end."
+                logger.info(details)
+            else:
+                details = f"Session '{previous_session_id}' ended at {datetime.now(tz=UTC)}."
+                logger.info(details)
+                self.clear_saved_session()
+
+            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)
 
-        cls._save_sessions_data(sessions_data, engine_id)
-        logger.info("Removed session: %s from engine: %s", session_id, engine_id)
+    def handle_get_session_request(self, _: AppGetSessionRequest) -> ResultPayload:
+        return AppGetSessionResultSuccess(
+            session_id=self.active_session_id,
+            result_details="Session ID retrieved successfully.",
+        )
+
+    def handle_session_heartbeat_request(self, request: SessionHeartbeatRequest) -> ResultPayload:  # noqa: ARG002
+        """Handle session heartbeat requests.
 
-    @classmethod
-    def get_sessions_for_engine(cls, engine_id: str) -> list[dict]:
-        """Get all sessions for a specific engine.
+        Simply verifies that the session is active and responds with success.
+        """
+        try:
+            active_session_id = self.active_session_id
+            if active_session_id is None:
+                details = "Session heartbeat received but no active session found"
+                logger.warning(details)
+                return SessionHeartbeatResultFailure(result_details=details)
+
+            details = f"Session heartbeat successful for session: {active_session_id}"
+            return SessionHeartbeatResultSuccess(result_details=details)
+        except Exception as err:
+            details = f"Failed to handle session heartbeat: {err}"
+            logger.error(details)
+            return SessionHeartbeatResultFailure(result_details=details)
+
+    @staticmethod
+    def _find_session_by_id(sessions_data: SessionsStorage, session_id: str) -> SessionData | None:
+        """Find a session by ID in the sessions data.
 
         Args:
-            engine_id: The engine ID to get sessions for
+            sessions_data: The sessions data structure
+            session_id: The session ID to find
 
         Returns:
-            list[dict]: List of session data for the specified engine
+            SessionData | None: The session data if found, None otherwise
         """
-        sessions_data = cls._load_sessions_data(engine_id)
-        return sessions_data.get("sessions", [])
+        for session in sessions_data.sessions:
+            if session.session_id == session_id:
+                return session
+        return None
 
-    @classmethod
-    def get_all_sessions_across_engines(cls) -> dict[str, list[dict]]:
-        """Get all sessions across all engines.
+    @staticmethod
+    def _get_session_state_file(engine_id: str | None = None) -> Path:
+        """Get the path to the session state storage file.
 
-        Returns:
-            dict[str, list[dict]]: Dictionary mapping engine IDs to their session lists
+        Args:
+            engine_id: Optional engine ID to get engine-specific session file
         """
-        from griptape_nodes.retained_mode.utils.engine_identity import EngineIdentity
-
-        all_engines = EngineIdentity.get_all_engines()
-        result = {}
+        return SessionManager._get_session_state_dir(engine_id) / SessionManager._SESSION_STATE_FILE
 
-        for engine in all_engines:
-            engine_id = engine.get("engine_id")
-            if engine_id:
-                result[engine_id] = cls.get_sessions_for_engine(engine_id)
+    @staticmethod
+    def _get_session_state_dir(engine_id: str | None = None) -> Path:
+        """Get the XDG state directory for session storage.
 
-        return result
+        Args:
+            engine_id: Optional engine ID to create engine-specific directory
+        """
+        base_dir = xdg_state_home() / "griptape_nodes"
+        if engine_id:
+            return base_dir / "engines" / engine_id
+        return base_dir

griptape_nodes/retained_mode/managers/settings.py

@@ -94,6 +94,10 @@ class MCPServerConfig(BaseModel):
 class AppInitializationComplete(BaseModel):
     libraries_to_register: list[str] = Field(default_factory=list)
     workflows_to_register: list[str] = Field(default_factory=list)
+    secrets_to_register: list[str] = Field(
+        default_factory=lambda: ["HF_TOKEN", "GT_CLOUD_API_KEY"],
+        description="Core secrets to register in the secrets manager. Library-specific secrets are registered automatically from library settings.",
+    )
     models_to_download: list[str] = Field(default_factory=list)
 
 
@@ -147,44 +151,6 @@ class Settings(BaseModel):
         category=APPLICATION_EVENTS,
         default_factory=AppEvents,
     )
-    nodes: dict[str, Any] = Field(
-        category=API_KEYS,
-        default_factory=lambda: {
-            "Griptape": {"GT_CLOUD_API_KEY": "$GT_CLOUD_API_KEY"},
-            "OpenAI": {"OPENAI_API_KEY": "$OPENAI_API_KEY"},
-            "Amazon": {
-                "AWS_ACCESS_KEY_ID": "$AWS_ACCESS_KEY_ID",
-                "AWS_SECRET_ACCESS_KEY": "$AWS_SECRET_ACCESS_KEY",
-                "AWS_DEFAULT_REGION": "$AWS_DEFAULT_REGION",
-                "AMAZON_OPENSEARCH_HOST": "$AMAZON_OPENSEARCH_HOST",
-                "AMAZON_OPENSEARCH_INDEX_NAME": "$AMAZON_OPENSEARCH_INDEX_NAME",
-            },
-            "Anthropic": {"ANTHROPIC_API_KEY": "$ANTHROPIC_API_KEY"},
-            "BlackForest Labs": {"BFL_API_KEY": "$BFL_API_KEY"},
-            "Microsoft Azure": {
-                "AZURE_OPENAI_ENDPOINT": "$AZURE_OPENAI_ENDPOINT",
-                "AZURE_OPENAI_DALL_E_3_ENDPOINT": "$AZURE_OPENAI_DALL_E_3_ENDPOINT",
-                "AZURE_OPENAI_DALL_E_3_API_KEY": "$AZURE_OPENAI_DALL_E_3_API_KEY",
-                "AZURE_OPENAI_API_KEY": "$AZURE_OPENAI_API_KEY",
-            },
-            "Cohere": {"COHERE_API_KEY": "$COHERE_API_KEY"},
-            "Eleven Labs": {"ELEVEN_LABS_API_KEY": "$ELEVEN_LABS_API_KEY"},
-            "Exa": {"EXA_API_KEY": "$EXA_API_KEY"},
-            "Grok": {"GROK_API_KEY": "$GROK_API_KEY"},
-            "Groq": {"GROQ_API_KEY": "$GROQ_API_KEY"},
-            "Nvidia": {"NVIDIA_API_KEY": "$NVIDIA_API_KEY"},
-            "Google": {"GOOGLE_API_KEY": "$GOOGLE_API_KEY", "GOOGLE_API_SEARCH_ID": "$GOOGLE_API_SEARCH_ID"},
-            "Huggingface": {"HUGGINGFACE_HUB_ACCESS_TOKEN": "$HUGGINGFACE_HUB_ACCESS_TOKEN"},
-            "LeonardoAI": {"LEONARDO_API_KEY": "$LEONARDO_API_KEY"},
-            "Pinecone": {
-                "PINECONE_API_KEY": "$PINECONE_API_KEY",
-                "PINECONE_ENVIRONMENT": "$PINECONE_ENVIRONMENT",
-                "PINECONE_INDEX_NAME": "$PINECONE_INDEX_NAME",
-            },
-            "Tavily": {"TAVILY_API_KEY": "$TAVILY_API_KEY"},
-            "Serper": {"SERPER_API_KEY": "$SERPER_API_KEY"},
-        },
-    )
     log_level: LogLevel = Field(category=EXECUTION, default=LogLevel.INFO)
     workflow_execution_mode: WorkflowExecutionMode = Field(
         category=EXECUTION,