zrb 1.0.0a21__py3-none-any.whl → 1.0.0b5__py3-none-any.whl

zrb/cmd/cmd_val.py

@@ -1,8 +1,9 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 
-from zrb.attr.type import fstring
+from zrb.attr.type import StrAttr, fstring
 from zrb.context.context import Context
+from zrb.util.attr import get_str_attr
 from zrb.util.file import read_file
 
 
@@ -13,22 +14,22 @@ class AnyCmdVal(ABC):
 
 
 class CmdPath(AnyCmdVal):
-    def __init__(self, path: str, auto_render: bool = True):
+    def __init__(self, path: StrAttr, auto_render: bool = True):
         self._path = path
         self._auto_render = auto_render
 
     def to_str(self, ctx: Context) -> str:
-        file_path = ctx.render(self._path) if self._auto_render else self._path
+        file_path = get_str_attr(ctx, self._path, "", self._auto_render)
         return read_file(file_path)
 
 
 class Cmd(AnyCmdVal):
-    def __init__(self, cmd: str, auto_render: str):
+    def __init__(self, cmd: StrAttr, auto_render: bool = True):
         self._cmd = cmd
         self._auto_render = auto_render
 
     def to_str(self, ctx: Context) -> str:
-        return ctx.render(self._cmd) if self._auto_render else self._cmd
+        return get_str_attr(ctx, self._cmd, "", self._auto_render)
 
 
 SingleCmdVal = AnyCmdVal | fstring | Callable[[Context], str]

zrb/config.py

@@ -77,13 +77,24 @@ WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES = int(
     os.getenv("ZRB_WEB_REFRESH_TOKEN_EXPIRE_MINUTES", "60")
 )
 LLM_MODEL = os.getenv("ZRB_LLM_MODEL", "ollama_chat/llama3.1")
-LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", "You are a helpful assistant")
+
+_DEFAULT_PROMPT = (
+    "You are a helpful AI assistant capable of using various tools to answer user queries. When solving a problem:\n"
+    "1. Carefully analyze the user's request and identify what information is needed to provide a complete answer.\n"
+    "2. Determine which available tools can help you gather the necessary information.\n"
+    "3. Call tools strategically and in a logical sequence to collect required data.\n"
+    "4. If a tool provides incomplete information, intelligently decide which additional tool or approach to use.\n"
+    "5. Always aim to provide the most accurate and helpful response possible."
+)
+LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", _DEFAULT_PROMPT)
+LLM_HISTORY_DIR = os.getenv(
+    "ZRB_LLM_HISTORY_DIR", os.path.expanduser(os.path.join("~", ".zrb-llm-history"))
+)
 LLM_HISTORY_FILE = os.getenv(
-    "ZRB_LLM_HISTORY_FILE",
-    os.path.expanduser(os.path.join("~", ".zrb-llm-history.json")),
+    "ZRB_LLM_HISTORY_FILE", os.path.join(LLM_HISTORY_DIR, "history.json")
 )
 LLM_ALLOW_ACCESS_SHELL = to_boolean(os.getenv("ZRB_LLM_ACCESS_FILE", "1"))
-LLM_ALLOW_ACCESS_WEB = to_boolean(os.getenv("ZRB_LLM_ACCESS_WEB", "1"))
+LLM_ALLOW_ACCESS_INTERNET = to_boolean(os.getenv("ZRB_LLM_ACCESS_INTERNET", "1"))
 RAG_EMBEDDING_MODEL = os.getenv("ZRB_RAG_EMBEDDING_MODEL", "ollama/nomic-embed-text")
 RAG_CHUNK_SIZE = int(os.getenv("ZRB_RAG_CHUNK_SIZE", "1024"))
 RAG_OVERLAP = int(os.getenv("ZRB_RAG_OVERLAP", "128"))

zrb/content_transformer/any_content_transformer.py

@@ -4,6 +4,13 @@ from zrb.context.any_context import AnyContext
 
 
 class AnyContentTransformer(ABC):
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Transformer's name"""
+        pass
+
     @abstractmethod
     def match(self, ctx: AnyContext, file_path: str) -> bool:
         """

zrb/content_transformer/content_transformer.py

@@ -10,6 +10,7 @@ from zrb.util.file import read_file, write_file
 class ContentTransformer(AnyContentTransformer):
     def __init__(
         self,
+        name: str,
         match: list[str] | str | Callable[[AnyContext, str], bool],
         transform: (
             dict[str, str | Callable[[AnyContext], str]]
@@ -17,10 +18,15 @@ class ContentTransformer(AnyContentTransformer):
         ),
         auto_render: bool = True,
     ):
+        self._name = name
         self._match = match
         self._transform_file = transform
         self._auto_render = auto_render
 
+    @property
+    def name(self) -> str:
+        return self._name
+
     def match(self, ctx: AnyContext, file_path: str) -> bool:
         if callable(self._match):
             return self._match(ctx, file_path)

zrb/input/any_input.py

@@ -19,6 +19,11 @@ class AnyInput(ABC):
     def prompt_message(self) -> str:
         pass
 
+    @property
+    @abstractmethod
+    def allow_positional_parsing(self) -> bool:
+        pass
+
     @abstractmethod
     def to_html(self, shared_ctx: AnySharedContext) -> str:
         pass

zrb/input/base_input.py

@@ -16,6 +16,7 @@ class BaseInput(AnyInput):
         default_str: StrAttr = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         self._name = name
         self._description = description
@@ -23,6 +24,7 @@ class BaseInput(AnyInput):
         self._default_str = default_str
         self._auto_render = auto_render
         self._allow_empty = allow_empty
+        self._allow_positional_parsing = allow_positional_parsing
 
     def __repr__(self):
         return f"<{self.__class__.__name__} name={self._name}>"
@@ -39,6 +41,10 @@ class BaseInput(AnyInput):
     def prompt_message(self) -> str:
         return self._prompt if self._prompt is not None else self.name
 
+    @property
+    def allow_positional_parsing(self) -> bool:
+        return self._allow_positional_parsing
+
     def to_html(self, ctx: AnySharedContext) -> str:
         name = self.name
         description = self.description

zrb/input/bool_input.py

@@ -13,6 +13,7 @@ class BoolInput(BaseInput):
         default_str: StrAttr = "False",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -21,6 +22,7 @@ class BoolInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
 
     def to_html(self, ctx: AnySharedContext) -> str:

zrb/input/float_input.py

@@ -12,6 +12,7 @@ class FloatInput(BaseInput):
         default_str: StrAttr = "0.0",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -20,6 +21,7 @@ class FloatInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
 
     def to_html(self, ctx: AnySharedContext) -> str:

zrb/input/int_input.py

@@ -12,6 +12,7 @@ class IntInput(BaseInput):
         default_str: StrAttr = "0",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -20,6 +21,7 @@ class IntInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
 
     def to_html(self, ctx: AnySharedContext) -> str:

zrb/input/option_input.py

@@ -14,6 +14,7 @@ class OptionInput(BaseInput):
         default_str: StrAttr = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -22,6 +23,7 @@ class OptionInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
         self._options = options
 

zrb/input/password_input.py

@@ -14,6 +14,7 @@ class PasswordInput(BaseInput):
         default_str: str | Callable[[AnySharedContext], str] = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -22,6 +23,7 @@ class PasswordInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
         self._is_secret = True
 

zrb/input/text_input.py

@@ -18,6 +18,7 @@ class TextInput(BaseInput):
         default_str: str | Callable[[AnySharedContext], str] = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
         editor: str = DEFAULT_EDITOR,
         extension: str = ".txt",
         comment_start: str | None = None,
@@ -30,6 +31,7 @@ class TextInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
         self._editor = editor
         self._extension = extension

zrb/runner/cli.py

@@ -1,17 +1,15 @@
 import sys
 from typing import Any
 
-from zrb.config import BANNER, WEB_HTTP_PORT
+from zrb.config import BANNER, VERSION, WEB_HTTP_PORT
 from zrb.context.any_context import AnyContext
 from zrb.context.shared_context import SharedContext
 from zrb.group.group import Group
 from zrb.runner.common_util import get_run_kwargs
-from zrb.runner.web_app import create_app
-from zrb.runner.web_config import web_config
+from zrb.runner.web_app import create_web_app
+from zrb.runner.web_config.config_factory import web_config
 from zrb.session.session import Session
-from zrb.session_state_logger.default_session_state_logger import (
-    default_session_state_logger,
-)
+from zrb.session_state_logger.session_state_logger_factory import session_state_logger
 from zrb.task.any_task import AnyTask
 from zrb.task.make_task import make_task
 from zrb.util.cli.style import (
@@ -151,6 +149,15 @@ class Cli(Group):
 
 
 cli = Cli(name="zrb", description="Your Automation Powerhouse", banner=BANNER)
+
+
+@make_task(
+    name="version", description="🌟 Get current Zrb version", retries=0, group=cli
+)
+def get_version(_: AnyContext):
+    return VERSION
+
+
 server_group = cli.add_group(
     Group(name="server", description="🌐 Server related command")
 )
@@ -167,6 +174,6 @@ server_group = cli.add_group(
 async def start_server(_: AnyContext):
     from uvicorn import Config, Server
 
-    app = create_app(cli, web_config, default_session_state_logger)
+    app = create_web_app(cli, web_config, session_state_logger)
     server = Server(Config(app=app, host="0.0.0.0", port=WEB_HTTP_PORT, loop="asyncio"))
     await server.serve()

zrb/runner/common_util.py

@@ -15,7 +15,7 @@ def get_run_kwargs(
         if task_input.name in str_kwargs:
             # Update shared context for next input default value
             task_input.update_shared_context(shared_ctx, str_kwargs[task_input.name])
-        elif arg_index < len(args):
+        elif arg_index < len(args) and task_input.allow_positional_parsing:
             run_kwargs[task_input.name] = args[arg_index]
             # Update shared context for next input default value
             task_input.update_shared_context(shared_ctx, run_kwargs[task_input.name])

zrb/runner/web_app.py

@@ -1,60 +1,38 @@
 import asyncio
-import json
-import os
 import sys
-from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Annotated
+from typing import TYPE_CHECKING
 
 from zrb.config import BANNER, VERSION
-from zrb.context.shared_context import SharedContext
 from zrb.group.any_group import AnyGroup
-from zrb.runner.common_util import get_run_kwargs
-from zrb.runner.web_config import (
-    NewSessionResponse,
-    RefreshTokenRequest,
-    Token,
-    WebConfig,
-)
-from zrb.runner.web_controller.error_page.controller import show_error_page
-from zrb.runner.web_controller.group_info_page.controller import show_group_info_page
-from zrb.runner.web_controller.home_page.controller import show_home_page
-from zrb.runner.web_controller.login_page.controller import show_login_page
-from zrb.runner.web_controller.logout_page.controller import show_logout_page
-from zrb.runner.web_controller.session_page.controller import show_session_page
-from zrb.runner.web_util import get_refresh_token_js
-from zrb.session.session import Session
-from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_route.docs_route import serve_docs
+from zrb.runner.web_route.error_page.serve_default_404 import serve_default_404
+from zrb.runner.web_route.home_page.home_page_route import serve_home_page
+from zrb.runner.web_route.login_api_route import serve_login_api
+from zrb.runner.web_route.login_page.login_page_route import serve_login_page
+from zrb.runner.web_route.logout_api_route import serve_logout_api
+from zrb.runner.web_route.logout_page.logout_page_route import serve_logout_page
+from zrb.runner.web_route.node_page.node_page_route import serve_node_page
+from zrb.runner.web_route.refresh_token_api_route import serve_refresh_token_api
+from zrb.runner.web_route.static.static_route import serve_static_resources
+from zrb.runner.web_route.task_input_api_route import serve_task_input_api
+from zrb.runner.web_route.task_session_api_route import serve_task_session_api
 from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
-from zrb.task.any_task import AnyTask
-from zrb.util.group import NodeNotFoundError, extract_node_from_args, get_node_path
 
 if TYPE_CHECKING:
     # We want fastapi to only be loaded when necessary to decrease footprint
     from fastapi import FastAPI
 
 
-def create_app(
+def create_web_app(
     root_group: AnyGroup,
     web_config: WebConfig,
     session_state_logger: AnySessionStateLogger,
 ) -> "FastAPI":
     from contextlib import asynccontextmanager
 
-    from fastapi import (
-        Cookie,
-        Depends,
-        FastAPI,
-        HTTPException,
-        Query,
-        Request,
-        Response,
-    )
-    from fastapi.openapi.docs import get_swagger_ui_html
-    from fastapi.responses import FileResponse, HTMLResponse, PlainTextResponse
-    from fastapi.security import OAuth2PasswordRequestForm
-    from fastapi.staticfiles import StaticFiles
+    from fastapi import FastAPI
 
-    _STATIC_DIR = os.path.join(os.path.dirname(__file__), "web_controller", "static")
     _COROS = []
 
     @asynccontextmanager
@@ -75,247 +53,17 @@ def create_app(
         lifespan=lifespan,
         docs_url=None,
     )
-    app.mount("/static", StaticFiles(directory=_STATIC_DIR), name="static")
-
-    # Serve static files
-    @app.get("/static/{file_path:path}", include_in_schema=False)
-    async def static_files(file_path: str):
-        full_path = os.path.join(_STATIC_DIR, file_path)
-        if os.path.isfile(full_path):
-            return FileResponse(full_path)
-        raise HTTPException(status_code=404, detail="File not found")
-
-    @app.get("/refresh-token.js", include_in_schema=False)
-    async def refresh_token_js():
-        return PlainTextResponse(
-            content=get_refresh_token_js(
-                60 * web_config.refresh_token_expire_minutes / 3
-            ),
-            media_type="application/javascript",
-        )
-
-    @app.get("/docs", include_in_schema=False)
-    async def swagger_ui_html():
-        return get_swagger_ui_html(
-            openapi_url="/openapi.json",
-            title="Zrb",
-            swagger_favicon_url="/static/favicon-32x32.png",
-        )
-
-    # Serve homepage
-    @app.get("/", response_class=HTMLResponse, include_in_schema=False)
-    @app.get("/ui", response_class=HTMLResponse, include_in_schema=False)
-    @app.get("/ui/", response_class=HTMLResponse, include_in_schema=False)
-    async def home_page_ui(request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        return show_home_page(user, root_group)
-
-    @app.get("/ui/{path:path}", response_class=HTMLResponse, include_in_schema=False)
-    async def ui_page(path: str, request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        # Avoid capturing '/ui' itself
-        if not path:
-            return show_error_page(user, root_group, 422, "Undefined path")
-        args = path.strip("/").split("/")
-        try:
-            node, node_path, residual_args = extract_node_from_args(root_group, args)
-        except NodeNotFoundError as e:
-            return show_error_page(user, root_group, 404, str(e))
-        url = f"/ui/{'/'.join(node_path)}/"
-        if isinstance(node, AnyTask):
-            if not user.can_access_task(node):
-                return show_error_page(user, root_group, 403, "Forbidden")
-            shared_ctx = SharedContext(env=dict(os.environ))
-            session = Session(shared_ctx=shared_ctx, root_group=root_group)
-            return show_session_page(
-                user, root_group, node, session, url, residual_args
-            )
-        elif isinstance(node, AnyGroup):
-            if not user.can_access_group(node):
-                return show_error_page(user, root_group, 403, "Forbidden")
-            return show_group_info_page(user, root_group, node, url)
-        return show_error_page(user, root_group, 404, "Not found")
-
-    @app.get("/login", response_class=HTMLResponse, include_in_schema=False)
-    async def login(request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        return show_login_page(user, root_group)
-
-    @app.get("/logout", response_class=HTMLResponse, include_in_schema=False)
-    async def logout(request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        return show_logout_page(user, root_group)
-
-    @app.post("/api/v1/login")
-    async def login_api(
-        response: Response, form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
-    ):
-        token = web_config.generate_tokens_by_credentials(
-            username=form_data.username, password=form_data.password
-        )
-        if token is None:
-            raise HTTPException(
-                status_code=400, detail="Incorrect username or password"
-            )
-        _set_auth_cookie(response, token)
-        return token
-
-    @app.post("/api/v1/refresh-token")
-    async def refresh_token_api(
-        response: Response,
-        body: RefreshTokenRequest = None,
-        refresh_token_cookie: str = Cookie(
-            None, alias=web_config.refresh_token_cookie_name
-        ),
-    ):
-        # Try to get the refresh token from the request body first
-        refresh_token = body.refresh_token if body else None
-        # If not in the body, try to get it from the cookie
-        if not refresh_token:
-            refresh_token = refresh_token_cookie
-        # If we still don't have a refresh token, raise an exception
-        if not refresh_token:
-            raise HTTPException(status_code=400, detail="Refresh token not provided")
-        # Get token
-        new_token = web_config.regenerate_tokens(refresh_token)
-        _set_auth_cookie(response, new_token)
-        return new_token
-
-    def _set_auth_cookie(response: Response, token: Token):
-        access_token_max_age = web_config.access_token_expire_minutes * 60
-        refresh_token_max_age = web_config.refresh_token_expire_minutes * 60
-        now = datetime.now(timezone.utc)
-        response.set_cookie(
-            key=web_config.access_token_cookie_name,
-            value=token.access_token,
-            httponly=True,
-            max_age=access_token_max_age,
-            expires=now + timedelta(seconds=access_token_max_age),
-        )
-        response.set_cookie(
-            key=web_config.refresh_token_cookie_name,
-            value=token.refresh_token,
-            httponly=True,
-            max_age=refresh_token_max_age,
-            expires=now + timedelta(seconds=refresh_token_max_age),
-        )
-
-    @app.get("/api/v1/logout")
-    @app.post("/api/v1/logout")
-    async def logout_api(response: Response):
-        response.delete_cookie(web_config.access_token_cookie_name)
-        response.delete_cookie(web_config.refresh_token_cookie_name)
-        return {"message": "Logout successful"}
-
-    @app.post("/api/v1/task-sessions/{path:path}")
-    async def create_new_task_session_api(
-        path: str,
-        request: Request,
-    ) -> NewSessionResponse:
-        """
-        Creating new session
-        """
-        user = await web_config.get_user_from_request(request)
-        args = path.strip("/").split("/")
-        task, _, residual_args = extract_node_from_args(root_group, args)
-        if isinstance(task, AnyTask):
-            if not user.can_access_task(task):
-                raise HTTPException(status_code=403)
-            session_name = residual_args[0] if residual_args else None
-            if not session_name:
-                body = await request.json()
-                shared_ctx = SharedContext(env=dict(os.environ))
-                session = Session(shared_ctx=shared_ctx, root_group=root_group)
-                coro = asyncio.create_task(task.async_run(session, str_kwargs=body))
-                _COROS.append(coro)
-                coro.add_done_callback(lambda coro: _COROS.remove(coro))
-                return NewSessionResponse(session_name=session.name)
-        raise HTTPException(status_code=404)
-
-    @app.get("/api/v1/task-inputs/{path:path}", response_model=dict[str, str])
-    async def get_default_inputs_api(
-        path: str,
-        request: Request,
-        query: str = Query("{}", description="JSON encoded inputs"),
-    ) -> dict[str, str]:
-        """
-        Getting input completion for path
-        """
-        user = await web_config.get_user_from_request(request)
-        args = path.strip("/").split("/")
-        task, _, _ = extract_node_from_args(root_group, args)
-        if isinstance(task, AnyTask):
-            if not user.can_access_task(task):
-                raise HTTPException(status_code=403)
-            query_dict = json.loads(query)
-            run_kwargs = get_run_kwargs(
-                task=task, args=[], kwargs=query_dict, prompt=False
-            )
-            return run_kwargs
-        raise HTTPException(status_code=404, detail="Not Found")
-
-    @app.get(
-        "/api/v1/task-sessions/{path:path}",
-        response_model=SessionStateLog | SessionStateLogList,
-    )
-    async def get_session_api(
-        path: str,
-        request: Request,
-        min_start_query: str = Query(default=None, alias="from"),
-        max_start_query: str = Query(default=None, alias="to"),
-        page: int = Query(default=0, alias="page"),
-        limit: int = Query(default=10, alias="limit"),
-    ) -> SessionStateLog | SessionStateLogList:
-        """
-        Getting existing session or sessions
-        """
-        user = await web_config.get_user_from_request(request)
-        args = path.strip("/").split("/")
-        task, _, residual_args = extract_node_from_args(root_group, args)
-        if isinstance(task, AnyTask) and residual_args:
-            if not user.can_access_task(task):
-                raise HTTPException(status_code=403)
-            if residual_args[0] == "list":
-                task_path = get_node_path(root_group, task)
-                max_start_time = (
-                    datetime.now()
-                    if max_start_query is None
-                    else datetime.strptime(max_start_query, "%Y-%m-%d %H:%M:%S")
-                )
-                min_start_time = (
-                    max_start_time - timedelta(hours=1)
-                    if min_start_query is None
-                    else datetime.strptime(min_start_query, "%Y-%m-%d %H:%M:%S")
-                )
-                return _get_existing_sessions(
-                    task_path, min_start_time, max_start_time, page, limit
-                )
-            else:
-                return _read_session(residual_args[0])
-        raise HTTPException(status_code=404, detail="Not Found")
-
-    def _get_existing_sessions(
-        task_path: list[str],
-        min_start_time: datetime,
-        max_start_time: datetime,
-        page: int,
-        limit: int,
-    ) -> SessionStateLogList:
-        try:
-            return session_state_logger.list(
-                task_path,
-                min_start_time=min_start_time,
-                max_start_time=max_start_time,
-                page=page,
-                limit=limit,
-            )
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
-
-    def _read_session(session_name: str) -> SessionStateLog:
-        try:
-            return session_state_logger.read(session_name)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
 
+    serve_default_404(app, root_group, web_config)
+    serve_static_resources(app, web_config)
+    serve_docs(app)
+    serve_home_page(app, root_group, web_config)
+    serve_login_page(app, root_group, web_config)
+    serve_logout_page(app, root_group, web_config)
+    serve_node_page(app, root_group, web_config)
+    serve_login_api(app, web_config)
+    serve_logout_api(app, web_config)
+    serve_refresh_token_api(app, web_config)
+    serve_task_input_api(app, root_group, web_config)
+    serve_task_session_api(app, root_group, web_config, session_state_logger, _COROS)
     return app