nvidia-nat 1.1.0a20251020__py3-none-any.whl

nat/experimental/test_time_compute/selection/llm_based_plan_selector.py

@@ -0,0 +1,128 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import re
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.cli.register_workflow import register_ttc_strategy
+from nat.data_models.ttc_strategy import TTCStrategyBaseConfig
+from nat.experimental.test_time_compute.models.selection_config import LLMBasedPlanSelectionConfig
+from nat.experimental.test_time_compute.models.stage_enums import PipelineTypeEnum
+from nat.experimental.test_time_compute.models.stage_enums import StageTypeEnum
+from nat.experimental.test_time_compute.models.strategy_base import StrategyBase
+from nat.experimental.test_time_compute.models.ttc_item import TTCItem
+from nat.utils.io.model_processing import remove_r1_think_tags
+
+logger = logging.getLogger(__name__)
+
+
+class LLMBasedPlanSelector(StrategyBase):
+
+    def __init__(self, config: TTCStrategyBaseConfig) -> None:
+        super().__init__(config)
+        self.llm_bound = None
+
+    async def build_components(self, builder: Builder) -> None:
+        """
+        Build the components required for the selector.
+        """
+        self.llm_bound = await builder.get_llm(self.config.selection_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+
+    def supported_pipeline_types(self) -> [PipelineTypeEnum]:
+        return [PipelineTypeEnum.PLANNING]
+
+    def stage_type(self) -> StageTypeEnum:
+        return StageTypeEnum.SELECTION
+
+    async def ainvoke(self,
+                      items: list[TTCItem],
+                      original_prompt: str | None = None,
+                      agent_context: str | None = None,
+                      **kwargs) -> [TTCItem]:
+        """
+        Select the planning items based on the selection strategy.
+
+        Args:
+            original_prompt (str): The prompt the user provided the agent.
+            agent_context (str): The context of the agent, if applicable.
+            items (list[TTCItem]): The list of planning items to select from.
+
+        Returns:
+            TTCItem: The selected planning item.
+        """
+
+        try:
+            from langchain_core.language_models import BaseChatModel
+            from langchain_core.prompts import PromptTemplate
+        except ImportError:
+            raise ImportError("langchain-core is not installed. Please install it to use SingleShotMultiPlanPlanner.\n"
+                              "This error can be resolved by installing nvidia-nat-langchain.")
+
+        if not isinstance(self.llm_bound, BaseChatModel):
+            raise ValueError("The `selection_llm` must be an instance of `BaseChatModel`.")
+
+        model: BaseChatModel = self.llm_bound
+
+        plans = ""
+        for idx, item in enumerate(items):
+            plans += f"{idx + 1}. {remove_r1_think_tags(item.plan)}\n"
+
+        prompt_template = PromptTemplate(
+            template=self.config.selection_template,
+            input_variables=["original_prompt", "context", "plans"],
+            validate_template=True,
+        )
+
+        prompt = (await prompt_template.ainvoke(input={
+            "original_prompt": original_prompt, "context": agent_context, "plans": plans
+        })).to_string()
+
+        selected_plan_index = remove_r1_think_tags((await model.ainvoke(prompt)).content)
+
+        # Model Response will be 'Plan {plan number}'
+        # Use RegEx to extrac Plan {idx} from response strong
+        if not isinstance(selected_plan_index, str):
+            logger.warning(f"Invalid response from LLM for selected plan index: {selected_plan_index}.")
+            raise ValueError("Unable to parse the selected plan index.")
+        selected_plan_index = selected_plan_index.strip()
+        match = re.match(r'^\s*SELECTED PLAN:\s+(\d+)', selected_plan_index)
+        if not match:
+            logger.warning(f"Could not parse the selected plan index from the response: {selected_plan_index}.")
+            raise ValueError("The response format for selecting the plan is incorrect.")
+        index = match.group(1)
+
+        try:
+            selected_index = int(index) - 1
+            if selected_index < 0 or selected_index >= len(items):
+                raise ValueError("Selected index is out of range.")
+
+            # Return the selected planning item
+            return [items[selected_index]]
+        except ValueError as e:
+            logger.warning(f"Error parsing the selected plan index: {index}. Exception: {str(e)}")
+            raise ValueError(f"Failed to parse the selected plan index from the LLM response: {selected_plan_index}. "
+                             "Ensure the response follows the expected format.") from e
+
+
+@register_ttc_strategy(config_type=LLMBasedPlanSelectionConfig)
+async def register_llm_based_plan_selection(config: LLMBasedPlanSelectionConfig, builder: Builder):
+    """
+    Register the LLMBasedPlanSelector with the provided configuration.
+    """
+    selector = LLMBasedPlanSelector(config)
+    await selector.build_components(Builder())
+    yield selector

nat/experimental/test_time_compute/selection/threshold_selector.py

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from nat.builder.builder import Builder
+from nat.cli.register_workflow import register_ttc_strategy
+from nat.experimental.test_time_compute.models.selection_config import ThresholdSelectionConfig
+from nat.experimental.test_time_compute.models.stage_enums import PipelineTypeEnum
+from nat.experimental.test_time_compute.models.stage_enums import StageTypeEnum
+from nat.experimental.test_time_compute.models.strategy_base import StrategyBase
+from nat.experimental.test_time_compute.models.ttc_item import TTCItem
+
+logger = logging.getLogger(__name__)
+
+
+class ThresholdSelector(StrategyBase):
+    """
+    Downselects only those TTCItems whose 'score' >= config.threshold.
+    """
+
+    async def build_components(self, builder: Builder) -> None:
+        # No special components needed
+        pass
+
+    def supported_pipeline_types(self) -> list[PipelineTypeEnum]:
+        return [PipelineTypeEnum.TOOL_USE]
+
+    def stage_type(self) -> StageTypeEnum:
+        return StageTypeEnum.SELECTION
+
+    async def ainvoke(self,
+                      items: list[TTCItem],
+                      original_prompt: str | None = None,
+                      agent_context: str | None = None,
+                      **kwargs) -> list[TTCItem]:
+        threshold = self.config.threshold
+        selected = [itm for itm in items if (itm.score is not None and itm.score >= threshold)]
+        logger.info("ThresholdSelector: %d items => %d items (threshold=%.1f)", len(items), len(selected), threshold)
+        return selected
+
+
+@register_ttc_strategy(config_type=ThresholdSelectionConfig)
+async def register_threshold_selector(config: ThresholdSelectionConfig, builder: Builder):
+    selector = ThresholdSelector(config)
+    yield selector

nat/front_ends/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nat/front_ends/console/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nat/front_ends/console/authentication_flow_handler.py

@@ -0,0 +1,285 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import logging
+import secrets
+import webbrowser
+from dataclasses import dataclass
+from dataclasses import field
+
+import click
+import httpx
+import pkce
+from authlib.common.errors import AuthlibBaseError as OAuthError
+from authlib.integrations.httpx_client import AsyncOAuth2Client
+from fastapi import FastAPI
+from fastapi import Request
+
+from nat.authentication.interfaces import FlowHandlerBase
+from nat.authentication.oauth2.oauth2_auth_code_flow_provider_config import OAuth2AuthCodeFlowProviderConfig
+from nat.data_models.authentication import AuthenticatedContext
+from nat.data_models.authentication import AuthFlowType
+from nat.data_models.authentication import AuthProviderBaseConfig
+from nat.front_ends.fastapi.fastapi_front_end_controller import _FastApiFrontEndController
+
+logger = logging.getLogger(__name__)
+
+
+# --------------------------------------------------------------------------- #
+# Helpers                                                                     #
+# --------------------------------------------------------------------------- #
+@dataclass
+class _FlowState:
+    future: asyncio.Future = field(default_factory=asyncio.Future, init=False)
+    challenge: str | None = None
+    verifier: str | None = None
+    token_url: str | None = None
+    use_pkce: bool | None = None
+
+
+# --------------------------------------------------------------------------- #
+# Main handler                                                                #
+# --------------------------------------------------------------------------- #
+class ConsoleAuthenticationFlowHandler(FlowHandlerBase):
+    """
+    Authentication helper for CLI / console environments.  Supports:
+
+      • HTTP Basic (username/password)
+      • OAuth 2 Authorization‑Code with optional PKCE
+    """
+
+    # ----------------------------- lifecycle ----------------------------- #
+    def __init__(self) -> None:
+        super().__init__()
+        self._server_controller: _FastApiFrontEndController | None = None
+        self._redirect_app: FastAPI | None = None  # ★ NEW
+        self._flows: dict[str, _FlowState] = {}
+        self._active_flows = 0
+        self._server_lock = asyncio.Lock()
+        self._oauth_client: AsyncOAuth2Client | None = None
+
+    # ----------------------------- public API ---------------------------- #
+    async def authenticate(
+        self,
+        config: AuthProviderBaseConfig,
+        method: AuthFlowType,
+    ) -> AuthenticatedContext:
+        if method == AuthFlowType.HTTP_BASIC:
+            return self._handle_http_basic()
+        if method == AuthFlowType.OAUTH2_AUTHORIZATION_CODE:
+            if (not isinstance(config, OAuth2AuthCodeFlowProviderConfig)):
+                raise ValueError("Requested OAuth2 Authorization Code Flow but passed invalid config")
+
+            return await self._handle_oauth2_auth_code_flow(config)
+
+        raise NotImplementedError(f"Auth method “{method}” not supported.")
+
+    # --------------------- OAuth2 helper factories ----------------------- #
+    def construct_oauth_client(self, cfg: OAuth2AuthCodeFlowProviderConfig) -> AsyncOAuth2Client:
+        """
+        Separated for easy overriding in tests (to inject ASGITransport).
+        """
+        try:
+            client = AsyncOAuth2Client(
+                client_id=cfg.client_id,
+                client_secret=cfg.client_secret,
+                redirect_uri=cfg.redirect_uri,
+                scope=" ".join(cfg.scopes) if cfg.scopes else None,
+                token_endpoint=cfg.token_url,
+                token_endpoint_auth_method=cfg.token_endpoint_auth_method,
+                code_challenge_method="S256" if cfg.use_pkce else None,
+            )
+            self._oauth_client = client
+            return client
+        except (OAuthError, ValueError, TypeError) as e:
+            raise RuntimeError(f"Invalid OAuth2 configuration: {e}") from e
+        except Exception as e:
+            raise RuntimeError(f"Failed to create OAuth2 client: {e}") from e
+
+    def _create_authorization_url(self,
+                                  client: AsyncOAuth2Client,
+                                  config: OAuth2AuthCodeFlowProviderConfig,
+                                  state: str,
+                                  verifier: str | None = None,
+                                  challenge: str | None = None) -> str:
+        """
+        Create OAuth authorization URL with proper error handling.
+
+        Args:
+            client: The OAuth2 client instance
+            config: OAuth2 configuration
+            state: OAuth state parameter
+            verifier: PKCE verifier (if using PKCE)
+            challenge: PKCE challenge (if using PKCE)
+
+        Returns:
+            The authorization URL
+        """
+        try:
+            auth_url, _ = client.create_authorization_url(
+                config.authorization_url,
+                state=state,
+                code_verifier=verifier if config.use_pkce else None,
+                code_challenge=challenge if config.use_pkce else None,
+                **(config.authorization_kwargs or {})
+            )
+            return auth_url
+        except (OAuthError, ValueError, TypeError) as e:
+            raise RuntimeError(f"Error creating OAuth authorization URL: {e}") from e
+
+    # --------------------------- HTTP Basic ------------------------------ #
+    @staticmethod
+    def _handle_http_basic() -> AuthenticatedContext:
+        username = click.prompt("Username", type=str)
+        password = click.prompt("Password", type=str, hide_input=True)
+
+        import base64
+        credentials = f"{username}:{password}"
+        encoded_credentials = base64.b64encode(credentials.encode("utf-8")).decode("ascii")
+
+        return AuthenticatedContext(
+            headers={"Authorization": f"Bearer {encoded_credentials}"},
+            metadata={
+                "username": username, "password": password
+            },
+        )
+
+    # --------------------- OAuth2 Authorization‑Code --------------------- #
+    async def _handle_oauth2_auth_code_flow(self, cfg: OAuth2AuthCodeFlowProviderConfig) -> AuthenticatedContext:
+        state = secrets.token_urlsafe(16)
+        flow_state = _FlowState()
+        client = self.construct_oauth_client(cfg)
+
+        flow_state.token_url = cfg.token_url
+        flow_state.use_pkce = cfg.use_pkce
+
+        # PKCE bits
+        if cfg.use_pkce:
+            verifier, challenge = pkce.generate_pkce_pair()
+            flow_state.verifier = verifier
+            flow_state.challenge = challenge
+
+        # Create authorization URL using helper function
+        auth_url = self._create_authorization_url(client=client,
+                                                  config=cfg,
+                                                  state=state,
+                                                  verifier=flow_state.verifier,
+                                                  challenge=flow_state.challenge)
+
+        # Register flow + maybe spin up redirect handler
+        async with self._server_lock:
+            if (not self._redirect_app):
+                self._redirect_app = await self._build_redirect_app()
+
+            await self._start_redirect_server()
+
+            self._flows[state] = flow_state
+            self._active_flows += 1
+
+        try:
+            webbrowser.open(auth_url)
+            click.echo("Your browser has been opened for authentication.")
+        except Exception as e:
+            logger.error("Browser open failed: %s", e)
+            raise RuntimeError(f"Browser open failed: {e}") from e
+
+        # Wait for the redirect to land
+        try:
+            token = await asyncio.wait_for(flow_state.future, timeout=300)
+        except TimeoutError as exc:
+            raise RuntimeError("Authentication timed out (5 min).") from exc
+        finally:
+            async with self._server_lock:
+                self._flows.pop(state, None)
+                self._active_flows -= 1
+
+                if self._active_flows == 0:
+                    await self._stop_redirect_server()
+
+        return AuthenticatedContext(
+            headers={"Authorization": f"Bearer {token['access_token']}"},
+            metadata={
+                "expires_at": token.get("expires_at"), "raw_token": token
+            },
+        )
+
+    # --------------- redirect server / in‑process app -------------------- #
+    async def _build_redirect_app(self) -> FastAPI:
+        """
+        * If cfg.run_redirect_local_server == True → start a local server.
+        * Else → only build the redirect app and save it to `self._redirect_app`
+                 for in‑process testing.
+        """
+        app = FastAPI()
+
+        @app.get("/auth/redirect")
+        async def handle_redirect(request: Request):
+            state = request.query_params.get("state")
+            if not state or state not in self._flows:
+                return "Invalid state; restart authentication."
+            flow_state = self._flows[state]
+            try:
+                token = await self._oauth_client.fetch_token(  # type: ignore[arg-type]
+                    url=flow_state.token_url,
+                    authorization_response=str(request.url),
+                    code_verifier=flow_state.verifier if flow_state.use_pkce else None,
+                    state=state,
+                )
+                flow_state.future.set_result(token)
+            except OAuthError as e:
+                flow_state.future.set_exception(
+                    RuntimeError(f"Authorization server rejected request: {e.error} ({e.description})"))
+                return "Authentication failed: Authorization server rejected the request. You may close this tab."
+            except httpx.HTTPError as e:
+                flow_state.future.set_exception(RuntimeError(f"Network error during token fetch: {e}"))
+                return "Authentication failed: Network error occurred. You may close this tab."
+            except Exception as e:
+                flow_state.future.set_exception(RuntimeError(f"Authentication failed: {e}"))
+                return "Authentication failed: An unexpected error occurred. You may close this tab."
+            return "Authentication successful – you may close this tab."
+
+        return app
+
+    async def _start_redirect_server(self) -> None:
+        # If the server is already running, do nothing
+        if self._server_controller:
+            return
+        try:
+            if not self._redirect_app:
+                raise RuntimeError("Redirect app not built.")
+
+            self._server_controller = _FastApiFrontEndController(self._redirect_app)
+
+            asyncio.create_task(self._server_controller.start_server(host="localhost", port=8000))
+
+            # Give the server a moment to bind sockets before we return
+            await asyncio.sleep(0.3)
+        except Exception as exc:  # noqa: BLE001
+            raise RuntimeError(f"Failed to start redirect server: {exc}") from exc
+
+    async def _stop_redirect_server(self) -> None:
+        if self._server_controller:
+            await self._server_controller.stop_server()
+            self._server_controller = None
+
+    # ------------------------- test helpers ------------------------------ #
+    @property
+    def redirect_app(self) -> FastAPI | None:
+        """
+        In test mode (run_redirect_local_server=False) the in‑memory redirect
+        app is exposed for testing purposes.
+        """
+        return self._redirect_app

nat/front_ends/console/console_front_end_config.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+
+from pydantic import Field
+
+from nat.data_models.front_end import FrontEndBaseConfig
+
+
+class ConsoleFrontEndConfig(FrontEndBaseConfig, name="console"):
+    """
+    A front end that allows a NAT workflow to be run from the console.
+    """
+
+    input_query: list[str] | None = Field(default=None,
+                                          alias="input",
+                                          description="A single input to submit the the workflow.")
+    input_file: Path | None = Field(default=None,
+                                    description="Path to a json file of inputs to submit to the workflow.")

nat/front_ends/console/console_front_end_plugin.py

@@ -0,0 +1,108 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import logging
+
+import click
+from colorama import Fore
+
+from nat.data_models.interactive import HumanPromptModelType
+from nat.data_models.interactive import HumanResponse
+from nat.data_models.interactive import HumanResponseText
+from nat.data_models.interactive import InteractionPrompt
+from nat.front_ends.console.authentication_flow_handler import ConsoleAuthenticationFlowHandler
+from nat.front_ends.console.console_front_end_config import ConsoleFrontEndConfig
+from nat.front_ends.simple_base.simple_front_end_plugin_base import SimpleFrontEndPluginBase
+from nat.runtime.session import SessionManager
+
+logger = logging.getLogger(__name__)
+
+
+async def prompt_for_input_cli(question: InteractionPrompt) -> HumanResponse:
+    """
+    A simple CLI-based callback.
+    Takes question as str, returns the typed line as str.
+    """
+
+    if question.content.input_type == HumanPromptModelType.TEXT:
+        user_response = click.prompt(text=question.content.text)
+
+        return HumanResponseText(text=user_response)
+
+    raise ValueError("Unsupported human prompt input type. The run command only supports the 'HumanPromptText' "
+                     "input type. Please use the 'serve' command to ensure full support for all input types.")
+
+
+class ConsoleFrontEndPlugin(SimpleFrontEndPluginBase[ConsoleFrontEndConfig]):
+
+    def __init__(self, full_config):
+        super().__init__(full_config=full_config)
+
+        # Set the authentication flow handler
+        self.auth_flow_handler = ConsoleAuthenticationFlowHandler()
+
+    async def pre_run(self):
+        if (self.front_end_config.input_query is not None and self.front_end_config.input_file is not None):
+            raise click.UsageError("Must specify either --input or --input_file, not both")
+        if (self.front_end_config.input_query is None and self.front_end_config.input_file is None):
+            raise click.UsageError("Must specify either --input or --input_file")
+
+    async def run_workflow(self, session_manager: SessionManager):
+
+        assert session_manager is not None, "Session manager must be provided"
+        runner_outputs = None
+
+        if (self.front_end_config.input_query):
+
+            async def run_single_query(query):
+
+                async with session_manager.session(
+                        user_input_callback=prompt_for_input_cli,
+                        user_authentication_callback=self.auth_flow_handler.authenticate) as session:
+                    async with session.run(query) as runner:
+                        base_output = await runner.result(to_type=str)
+
+                        return base_output
+
+            # Convert to a list
+            input_list = list(self.front_end_config.input_query)
+            logger.debug("Processing input: %s", self.front_end_config.input_query)
+
+            # Make `return_exceptions=False` explicit; all exceptions are raised instead of being silenced
+            runner_outputs = await asyncio.gather(*[run_single_query(query) for query in input_list],
+                                                  return_exceptions=False)
+
+        elif (self.front_end_config.input_file):
+
+            # Run the workflow
+            with open(self.front_end_config.input_file, encoding="utf-8") as f:
+
+                async with session_manager.workflow.run(f) as runner:
+                    runner_outputs = await runner.result(to_type=str)
+        else:
+            assert False, "Should not reach here. Should have been caught by pre_run"
+
+        line = f"{'-' * 50}"
+        prefix = f"{line}\n{Fore.GREEN}Workflow Result:\n"
+        suffix = f"{Fore.RESET}\n{line}"
+
+        logger.info(f"{prefix}%s{suffix}", runner_outputs)
+
+        # (handler is a stream handler) => (level > INFO)
+        effective_level_too_high = all(
+            type(h) is not logging.StreamHandler or h.level > logging.INFO for h in logging.getLogger().handlers)
+        if effective_level_too_high:
+            print(f"{prefix}{runner_outputs}{suffix}")

nat/front_ends/console/register.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from nat.cli.register_workflow import register_front_end
+from nat.data_models.config import Config
+from nat.front_ends.console.console_front_end_config import ConsoleFrontEndConfig
+
+
+@register_front_end(config_type=ConsoleFrontEndConfig)
+async def register_fastapi_front_end(config: ConsoleFrontEndConfig, full_config: Config):
+    from nat.front_ends.console.console_front_end_plugin import ConsoleFrontEndPlugin
+
+    yield ConsoleFrontEndPlugin(full_config=full_config)