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

griptape_nodes/machines/sequential_resolution.py

@@ -63,12 +63,6 @@ class InitializeSpotlightState(State):
     @staticmethod
     async def on_enter(context: ResolutionContext) -> type[State] | None:
         # If the focus stack is empty
-        current_node = context.current_node
-        GriptapeNodes.EventManager().put_event(
-            ExecutionGriptapeNodeEvent(
-                wrapped_event=ExecutionEvent(payload=CurrentDataNodeEvent(node_name=current_node.name))
-            )
-        )
         if not context.paused:
             return InitializeSpotlightState
         return None
@@ -207,6 +201,11 @@ class ExecuteNodeState(State):
 
         # Clear all of the current output values
         # if node is locked, don't clear anything. skip all of this.
+        GriptapeNodes.EventManager().put_event(
+            ExecutionGriptapeNodeEvent(
+                wrapped_event=ExecutionEvent(payload=CurrentDataNodeEvent(node_name=current_node.name))
+            )
+        )
         if current_node.lock:
             return ExecuteNodeState
         await ExecuteNodeState.collect_values_from_upstream_nodes(context)
@@ -375,7 +374,10 @@ class SequentialResolutionMachine(FSM[ResolutionContext]):
         resolution_context = ResolutionContext()
         super().__init__(resolution_context)
 
-    async def resolve_node(self, node: BaseNode) -> None:
+    async def resolve_node(self, node: BaseNode | None = None) -> None:
+        if node is None:
+            msg = "SequentialResolutionMachine requires a node to resolve"
+            raise ValueError(msg)
         self._context.focus_stack.append(Focus(node=node))
         await self.start(InitializeSpotlightState)
 

griptape_nodes/node_library/library_registry.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any, ClassVar, NamedTuple
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from griptape_nodes.utils.metaclasses import SingletonMeta
 
@@ -85,6 +85,9 @@ class Setting(BaseModel):
     category: str  # Name of the category in the config
     contents: dict[str, Any]  # The actual settings content
     description: str | None = None  # Optional description for the setting
+    json_schema: dict[str, Any] | None = Field(
+        default=None, alias="schema"
+    )  # JSON schema for the setting (including enums)
 
 
 class LibrarySchema(BaseModel):
@@ -230,6 +233,36 @@ class LibraryRegistry(metaclass=SingletonMeta):
         # Ask the library to create the node.
         return dest_library.create_node(node_type=node_type, name=name, metadata=metadata)
 
+    @classmethod
+    def get_all_library_schemas(cls) -> dict[str, dict]:
+        """Get schemas from all loaded libraries.
+
+        Returns:
+            Dictionary mapping category names to their JSON Schema dicts
+        """
+        instance = cls()
+        schemas = {}
+
+        # Get explicit schemas from loaded libraries
+        for library in instance._libraries.values():
+            library_data = library.get_library_data()
+            if library_data.settings:
+                for setting in library_data.settings:
+                    if setting.json_schema:
+                        schemas[setting.category] = {
+                            "type": "object",
+                            "properties": setting.json_schema,
+                            "title": setting.description or f"{setting.category.title()} Settings",
+                        }
+                    else:
+                        # Create fallback schema for settings without explicit schemas
+                        schemas[setting.category] = {
+                            "type": "object",
+                            "title": setting.description or f"{setting.category.title()} Settings",
+                        }
+
+        return schemas
+
 
 class Library:
     """A collection of nodes curated by library author.

griptape_nodes/retained_mode/events/app_events.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from griptape_nodes.retained_mode.events.base_events import (
     AppPayload,
@@ -76,6 +76,10 @@ class AppGetSessionResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
 class AppInitializationComplete(AppPayload):
     """Application initialization completed successfully. All subsystems ready."""
 
+    libraries_to_register: list[str] = field(default_factory=list)
+    workflows_to_register: list[str] = field(default_factory=list)
+    models_to_download: list[str] = field(default_factory=list)
+
 
 @dataclass
 @PayloadRegistry.register

griptape_nodes/retained_mode/events/base_events.py

@@ -4,7 +4,7 @@ import json
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import asdict, dataclass, field, is_dataclass
-from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 
 from griptape.artifacts import BaseArtifact
 from griptape.mixins.serializable_mixin import SerializableMixin
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 class ResultDetail:
     """A single detail about an operation result, including logging level and human readable message."""
 
-    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+    level: int
     message: str
 
 
@@ -34,7 +34,7 @@ class ResultDetails:
         self,
         *result_details: ResultDetail,
         message: str | None = None,
-        level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = None,
+        level: int | None = None,
         logger: logging.Logger | str | None = "griptape_nodes",
     ):
         """Initialize with ResultDetail objects or create a single one from message/level.
@@ -67,8 +67,8 @@ class ResultDetails:
                     logger = logging.getLogger(logger)
 
                 for detail in self.result_details:
-                    numeric_level = getattr(logging, detail.level)
-                    logger.log(numeric_level, detail.message)
+                    # Handle both string and int levels
+                    logger.log(detail.level, detail.message)
             except Exception:  # noqa: S110
                 # If logging fails for any reason, don't let it break the ResultDetails creation
                 pass
@@ -140,7 +140,7 @@ class ResultPayloadSuccess(ResultPayload, ABC):
     def __post_init__(self) -> None:
         """Initialize success result with INFO level default for strings."""
         if isinstance(self.result_details, str):
-            self.result_details = ResultDetails(message=self.result_details, level="DEBUG")
+            self.result_details = ResultDetails(message=self.result_details, level=logging.DEBUG)
 
     def succeeded(self) -> bool:
         """Returns True as this is a success result.
@@ -162,7 +162,7 @@ class ResultPayloadFailure(ResultPayload, ABC):
     def __post_init__(self) -> None:
         """Initialize failure result with ERROR level default for strings."""
         if isinstance(self.result_details, str):
-            self.result_details = ResultDetails(message=self.result_details, level="ERROR")
+            self.result_details = ResultDetails(message=self.result_details, level=logging.ERROR)
 
     def succeeded(self) -> bool:
         """Returns False as this is a failure result.

griptape_nodes/retained_mode/events/config_events.py

@@ -194,3 +194,33 @@ class ResetConfigResultSuccess(ResultPayloadSuccess):
 @PayloadRegistry.register
 class ResetConfigResultFailure(ResultPayloadFailure):
     """Configuration reset failed. Common causes: file system errors, permission issues, initialization errors."""
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConfigSchemaRequest(RequestPayload):
+    """Get the JSON schema for the configuration model.
+
+    Use when: Frontend needs to understand field types, enums, and validation rules
+    for rendering appropriate UI components (dropdowns, text inputs, etc.).
+
+    Results: GetConfigSchemaResultSuccess (with schema) | GetConfigSchemaResultFailure (schema generation error)
+    """
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConfigSchemaResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Configuration schema retrieved successfully.
+
+    Args:
+        schema: The JSON schema for the configuration model
+    """
+
+    schema: dict[str, Any]
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConfigSchemaResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Configuration schema retrieval failed. Common causes: schema generation error, model validation issues."""

griptape_nodes/retained_mode/events/execution_events.py

@@ -227,8 +227,8 @@ class GetFlowStateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
         resolving_node: Name of the node currently being resolved (if any)
     """
 
-    control_node: str | None
-    resolving_node: str | None
+    control_nodes: list[str] | None
+    resolving_node: list[str] | None
 
 
 @dataclass

griptape_nodes/retained_mode/events/model_events.py

@@ -0,0 +1,296 @@
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.events.base_events import (
+    RequestPayload,
+    ResultPayloadFailure,
+    ResultPayloadSuccess,
+    WorkflowNotAlteredMixin,
+)
+from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
+
+
+@dataclass
+@PayloadRegistry.register
+class DownloadModelRequest(RequestPayload):
+    """Download a model from Hugging Face Hub.
+
+    Use when: Downloading models for local inference, caching models for offline use,
+    retrieving specific model versions or files from Hugging Face repositories.
+
+    Args:
+        model_id: Model identifier (e.g., "microsoft/DialoGPT-medium") or full URL to Hugging Face model
+        local_dir: Optional local directory to download the model to (defaults to Hugging Face cache)
+        repo_type: Type of repository ("model", "dataset", or "space"). Defaults to "model"
+        revision: Git revision (branch, tag, or commit hash) to download. Defaults to "main"
+        allow_patterns: List of glob patterns to include when downloading. None means all files
+        ignore_patterns: List of glob patterns to exclude when downloading
+
+    Results: DownloadModelResultSuccess (with local_path) | DownloadModelResultFailure (download error)
+    """
+
+    model_id: str
+    local_dir: str | None = None
+    repo_type: str = "model"
+    revision: str = "main"
+    allow_patterns: list[str] | None = None
+    ignore_patterns: list[str] | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class DownloadModelResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Model download completed successfully.
+
+    Args:
+        model_id: The model ID that was downloaded
+        repo_info: Additional repository information returned from the download
+    """
+
+    model_id: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DownloadModelResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Model download failed. Common causes: invalid model ID, network error, authentication required, storage full."""
+
+
+@dataclass
+class ModelInfo:
+    """Information about a model."""
+
+    model_id: str
+    local_path: str | None = None
+    size_bytes: int | None = None
+    author: str | None = None
+    downloads: int | None = None
+    likes: int | None = None
+    created_at: str | None = None
+    updated_at: str | None = None
+    task: str | None = None
+    library: str | None = None
+    tags: list[str] | None = None
+
+
+@dataclass
+class QueryInfo:
+    """Information about a search query."""
+
+    query: str | None = None
+    task: str | None = None
+    library: str | None = None
+    author: str | None = None
+    tags: list[str] | None = None
+    limit: int = 20
+    sort: str = "downloads"
+    direction: str = "desc"
+
+
+@dataclass
+@PayloadRegistry.register
+class ListModelsRequest(RequestPayload):
+    """List all downloaded models from the local cache.
+
+    Use when: Viewing what models are available locally, checking cache usage,
+    managing local model storage.
+
+    Results: ListModelsResultSuccess (with model list) | ListModelsResultFailure (listing error)
+    """
+
+
+@dataclass
+@PayloadRegistry.register
+class ListModelsResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Model listing completed successfully.
+
+    Args:
+        models: List of model information containing model_id, local_path, size_bytes, etc.
+    """
+
+    models: list[ModelInfo]
+
+
+@dataclass
+@PayloadRegistry.register
+class ListModelsResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Model listing failed. Common causes: cache directory access error, filesystem error."""
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteModelRequest(RequestPayload):
+    """Delete a downloaded model from the local cache.
+
+    Use when: Cleaning up disk space, removing unused models, managing local storage.
+
+    Args:
+        model_id: Model identifier to delete from local cache
+
+    Results: DeleteModelResultSuccess (deletion confirmed) | DeleteModelResultFailure (deletion error)
+    """
+
+    model_id: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteModelResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Model deletion completed successfully.
+
+    Args:
+        model_id: The model ID that was deleted
+        deleted_path: Local path that was removed
+    """
+
+    model_id: str
+    deleted_path: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteModelResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Model deletion failed. Common causes: model not found, filesystem error, permission denied."""
+
+
+@dataclass
+@PayloadRegistry.register
+class ListModelDownloadsRequest(RequestPayload):
+    """List download status for a specific model or all downloads.
+
+    Use when: Checking progress of ongoing downloads, viewing download history,
+    monitoring download completion.
+
+    Args:
+        model_id: Optional model identifier to get status for. If None, returns all downloads.
+
+    Results: ListModelDownloadsResultSuccess (with status data) | ListModelDownloadsResultFailure (query error)
+    """
+
+    model_id: str | None = None
+
+
+@dataclass
+class ModelDownloadStatus:
+    """Model download status tracking multiple files."""
+
+    model_id: str
+    status: str  # "downloading", "completed", "failed"
+    started_at: str
+    updated_at: str
+    total_files: int | None = None
+    completed_files: int | None = None
+    failed_files: int | None = None
+    # Optional fields for completed downloads
+    completed_at: str | None = None
+    local_path: str | None = None
+    # Optional fields for failed downloads
+    failed_at: str | None = None
+    error_message: str | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class ListModelDownloadsResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Model download status retrieved successfully.
+
+    Args:
+        downloads: List of download status records or single status if model_id was specified
+    """
+
+    downloads: list[ModelDownloadStatus]
+
+
+@dataclass
+@PayloadRegistry.register
+class ListModelDownloadsResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Model download status query failed. Common causes: filesystem error, invalid model ID."""
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteModelDownloadRequest(RequestPayload):
+    """Delete download status tracking records for a model.
+
+    Use when: Cleaning up orphaned download status files, removing tracking data
+    for models that are no longer needed.
+
+    Args:
+        model_id: Model identifier to remove download status for
+
+    Results: DeleteModelDownloadResultSuccess (deletion confirmed) | DeleteModelDownloadResultFailure (deletion error)
+    """
+
+    model_id: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteModelDownloadResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Model download status deletion completed successfully.
+
+    Args:
+        model_id: The model ID whose download status was deleted
+        deleted_path: Path to the status file that was removed
+    """
+
+    model_id: str
+    deleted_path: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteModelDownloadResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Model download status deletion failed. Common causes: status not found, filesystem error, permission denied."""
+
+
+@dataclass
+@PayloadRegistry.register
+class SearchModelsRequest(RequestPayload):
+    """Search for models on Hugging Face Hub.
+
+    Use when: Finding models by name, filtering models by task or library,
+    discovering available models for specific use cases.
+
+    Args:
+        query: Search query string to match against model names and descriptions
+        task: Filter by task type (e.g., "text-generation", "image-classification")
+        library: Filter by library (e.g., "transformers", "diffusers", "timm")
+        author: Filter by author/organization name
+        tags: List of tags to filter by
+        limit: Maximum number of results to return (default: 20, max: 100)
+        sort: Sort results by "downloads", "likes", "updated", or "created" (default: "downloads")
+        direction: Sort direction "asc" or "desc" (default: "desc")
+
+    Results: SearchModelsResultSuccess (with model list) | SearchModelsResultFailure (search error)
+    """
+
+    query: str | None = None
+    task: str | None = None
+    library: str | None = None
+    author: str | None = None
+    tags: list[str] | None = None
+    limit: int = 20
+    sort: str = "downloads"
+    direction: str = "desc"
+
+
+@dataclass
+@PayloadRegistry.register
+class SearchModelsResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Model search completed successfully.
+
+    Args:
+        models: List of model information containing id, author, downloads, etc.
+        total_results: Total number of models matching the search criteria
+        query_info: Information about the search query parameters used
+    """
+
+    models: list[ModelInfo]
+    total_results: int
+    query_info: QueryInfo
+
+
+@dataclass
+@PayloadRegistry.register
+class SearchModelsResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Model search failed. Common causes: network error, invalid parameters, API limits."""

griptape_nodes/retained_mode/griptape_nodes.py

@@ -62,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 (
@@ -138,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
@@ -160,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 (
@@ -193,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)
@@ -306,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
@@ -560,7 +568,8 @@ class GriptapeNodes(metaclass=SingletonMeta):
             GriptapeNodes.EngineIdentityManager().set_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="INFO")
+                engine_name=request.engine_name.strip(),
+                result_details=ResultDetails(message=details, level=logging.INFO),
             )
 
         except Exception as 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)
@@ -251,3 +259,9 @@ class AgentManager:
         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/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()