cmdbox 0.6.1.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

cmdbox/app/mcp.py

@@ -1,4 +1,4 @@
-from cmdbox.app import common, options
+from cmdbox.app import common, feature
 from cmdbox.app.options import Options
 from cmdbox.app.auth import signin
 from pathlib import Path
@@ -35,12 +35,14 @@ class Mcp:
         self.ver = ver
         self.signin = sign
 
-    def create_mcpserver(self, args:argparse.Namespace) -> Any:
+    def create_mcpserver(self, args:argparse.Namespace, tools:List[Any], web:Any) -> Any:
         """
         mcpserverを作成します
 
         Args:
             args (argparse.Namespace): 引数
+            tools (List[Any]): ツールのリスト
+            web (Any): Web関連のオブジェクト
 
         Returns:
             Any: FastMCP
@@ -58,10 +60,13 @@ class Mcp:
                 issuer=issuer,
                 audience=audience
             )
-            mcp = FastMCP(name=self.ver.__appid__, auth=auth)
+            mcp = FastMCP(name=self.ver.__appid__, tools=tools, auth=auth)
         else:
             self.logger.info(f"Using BearerAuthProvider without public key, issuer, or audience.")
-            mcp = FastMCP(name=self.ver.__appid__)
+            mcp = FastMCP(name=self.ver.__appid__, tools=tools)
+        mcp.add_middleware(self.create_mw_logging(self.logger, args))
+        mcp.add_middleware(self.create_mw_reqscope(self.logger, args, web))
+        mcp.add_middleware(self.create_mw_toollist(self.logger, args))
         return mcp
 
     def create_session_service(self, args:argparse.Namespace) -> Any:
@@ -119,7 +124,8 @@ class Mcp:
                       f"ユーザーがコマンドを実行したいとき、あなたは以下の手順に従ってコマンドを確実に実行してください。\n" + \
                       f"1. ユーザーのクエリからが実行したいコマンドを特定します。\n" + \
                       f"2. コマンド実行に必要なパラメータのなかで、ユーザーのクエリから取得できないものは、コマンド定義にあるデフォルト値を指定して実行してください。\n" + \
-                      f"3. もしエラーが発生した場合は、ユーザーにコマンド名とパラメータとエラー内容を提示してください。\n"
+                      f"3. もしエラーが発生した場合は、ユーザーにコマンド名とパラメータとエラー内容を提示してください。\n" \
+                      f"4. コマンドの実行結果は、json文字列で出力するようにしてください。この時json文字列は「```json」と「```」で囲んだ文字列にしてください。\n"
 
         description = description if is_japan else \
                       f"Command offer registered in {self.ver.__appid__}."
@@ -128,7 +134,8 @@ class Mcp:
                       f"When a user wants to execute a command, you follow these steps to ensure that the command is executed.\n" + \
                       f"1. Identify the command you want to execute from the user's query.\n" + \
                       f"2. Any parameters required to execute the command that cannot be obtained from the user's query should be executed with the default values provided in the command definition.\n" + \
-                      f"3. If an error occurs, provide the user with the command name, parameters, and error description.\n"
+                      f"3. If an error occurs, provide the user with the command name, parameters, and error description.\n" \
+                      f"4. The result of the command execution should be output as a json string. The json string should be a string enclosed in '```json' and '```'."
 
         description = args.agent_description if args.agent_description else description
         instruction = args.agent_instruction if args.agent_instruction else instruction
@@ -235,13 +242,311 @@ class Mcp:
             session_service=session_service,
         )
 
-    def init_agent_runner(self, logger:logging.Logger, args:argparse.Namespace) -> Tuple[Any, Any]:
+    def _to_schema(self, o:Dict[str, Any], is_japan:bool) -> Dict[str, Any]:
+        t, m = o["type"], o["multi"]
+        title = o['opt'].title().replace('_', ' ')
+        description = o['description_ja'] if is_japan else o['description_en']
+        if t == Options.T_BOOL:
+            return dict(title=title, type="array", items=dict(type="boolean"), description=description) if m \
+                else dict(title=title, type="boolean", description=description)
+        if t == Options.T_DATE:
+            return dict(title=title, type="array", items=dict(type="string"), description=description) if m \
+                else dict(title=title, type="string", description=description)
+        if t == Options.T_DATETIME:
+            return dict(title=title, type="array", items=dict(type="string"), description=description) if m \
+                else dict(title=title, type="string", description=description)
+        if t == Options.T_DICT:
+            return dict(title=title, type="array", items=dict(additionalProperties=True, type="object"), description=description) if m \
+                else dict(title=title, type="object", description=description)
+        if t == Options.T_DIR or t == Options.T_FILE:
+            return dict(title=title, type="array", items=dict(type="string"), description=description) if m \
+                else dict(title=title, type="string", description=description)
+        if t == Options.T_FLOAT:
+            return dict(title=title, type="array", items=dict(type="number"), description=description) if m \
+                else dict(title=title, type="number", description=description)
+        if t == Options.T_INT:
+            return dict(title=title, type="array", items=dict(type="integer"), description=description) if m \
+                else dict(title=title, type="integer", description=description)
+        if t == Options.T_STR or t == Options.T_TEXT:
+            return dict(title=title, type="array", items=dict(type="string"), description=description) if m \
+                    else dict(title=title, type="string", description=description)
+        raise ValueError(f"Unknown type: {t} for option {o['opt']}")
+
+    def _ds(self, d:str) -> str:
+        return f'"{d}"' if d is not None else 'None'
+    
+    def _doc_arg_type(self, o:Dict[str, Any], use_default:True) -> str:
+        t, m, d, r = o["type"], o["multi"], o["default"], o["required"]
+        ret = ""
+        dft = "None"
+        if t == Options.T_BOOL:
+            ret = "List[bool]" if m else f"bool"
+            dft = "[]" if m else f"{d}"
+        elif t == Options.T_DATE:
+            ret = "List[str]" if m else f"str"
+            dft = "[]" if m else self._ds(d)
+        elif t == Options.T_DATETIME:
+            ret = "List[str]" if m else f"str"
+            dft = "[]" if m else self._ds(d)
+        elif t == Options.T_DICT:
+            ret = "Dict" if m else f"Dict"
+            dft = "{}" if m else self._ds(d)
+        elif t == Options.T_DIR or t == Options.T_FILE:
+            if d is not None: d = str(d).replace('\\', '/')
+            ret = "List[str]" if m else f"str"
+            dft = "[]" if m else self._ds(d)
+        elif t == Options.T_FLOAT:
+            ret ="List[float]" if m else f"float"
+            dft ="[]" if m else f"{d}"
+        elif t == Options.T_INT:
+            ret = "List[int]" if m else f"int"
+            dft = "[]" if m else f"{d}"
+        elif t == Options.T_STR or t == Options.T_TEXT:
+            ret = "List[str]" if m else f"str"
+            dft = "[]" if m else self._ds(d)
+        else:
+            raise ValueError(f"Unknown type: {t} for option {o['opt']}")
+        return f"{ret}={dft}" if use_default else ret
+
+    def _doc_arg(self, o:Dict[str, Any], is_japan) -> str:
+        s = f'        {o["opt"]}:{self._doc_arg_type(o, True)} '
+        s += f'{o["description_ja"] if is_japan else o["description_en"]}'
+        return s
+
+    def _create_func_txt(self, func_name:str, mode:str, cmd:str, is_japan:bool, options:Options, title:str='') -> str:
+        description = options.get_cmd_attr(mode, cmd, 'description_ja' if is_japan else 'description_en')
+        choices = options.get_cmd_choices(mode, cmd, False)
+        func_doc_args = "\n".join([self._doc_arg(o, is_japan) for o in choices])
+        func_txt  = f"def {func_name}(*args, **kwargs):\n"
+        func_txt += f'    """\n'
+        func_txt += f'    {func_name} - MCP Tool Function\n'
+        func_txt += f'    {description}\n'
+        func_txt += f'\n'
+        func_txt += f'    Args:\n'
+        func_txt += f'        {func_doc_args}\n'
+        func_txt += f'\n'
+        func_txt += f'    Returns:\n'
+        func_txt += f'        Dict[str, Any]: 実行結果\n'
+        func_txt += f'    """\n'
+        func_txt += f'    logger = logging.getLogger("web")\n'
+        func_txt +=  '    opt = {o["opt"]: kwargs.get(o["opt"], o["default"]) for o in options.get_cmd_choices("'+mode+'", "'+cmd+'", False)}\n'
+        func_txt += f'    opt["data"] = Path(opt["data"]) if hasattr(opt, "data") else common.HOME_DIR / f".{self.ver.__appid__}"\n'
+        func_txt += f'    if "{title}":\n'
+        func_txt += f'        opt_path = opt["data"] / ".cmds" / f"cmd-{title}.json"\n'
+        func_txt += f'        opt.update(common.loadopt(opt_path))\n'
+        func_txt += f'    scope = signin.get_request_scope()\n'
+        func_txt += f'    opt["mode"] = "{mode}"\n'
+        func_txt += f'    opt["cmd"] = "{cmd}"\n'
+        func_txt += f'    opt["format"] = False\n'
+        func_txt += f'    opt["output_json"] = None\n'
+        func_txt += f'    opt["output_json_append"] = False\n'
+        func_txt += f'    opt["debug"] = logger.level == logging.DEBUG\n'
+        func_txt += f'    opt["signin_file"] = scope["web"].signin_file\n'
+        func_txt += f'    args = argparse.Namespace(**opt)\n'
+        func_txt += f'    signin_data = signin.Signin.load_signin_file(args.signin_file)\n'
+        func_txt += f'    req = scope["req"] if scope["req"] is not None else scope["websocket"]\n'
+        func_txt += f'    sign = signin.Signin._check_signin(req, scope["res"], signin_data, logger)\n'
+        func_txt += f'    if sign is not None:\n'
+        func_txt += f'        logger.warning("Unable to execute command because authentication information cannot be obtained")\n'
+        func_txt += f'        return dict(warn="Unable to execute command because authentication information cannot be obtained")\n'
+        func_txt += f'    groups = req.session["signin"]["groups"]\n'
+        func_txt += f'    if not signin.Signin._check_cmd(signin_data, groups, "{mode}", "{cmd}", logger):\n'
+        func_txt += f'        logger.warning("You do not have permission to execute this command.")\n'
+        func_txt += f'        return dict(warn="You do not have permission to execute this command.")\n'
+        func_txt += f'    feat = options.get_cmd_attr("{mode}", "{cmd}", "feature")\n'
+        func_txt += f'    args.groups = groups\n'
+        func_txt += f'    try:\n'
+        func_txt += f'        st, ret, _ = feat.apprun(logger, args, time.perf_counter(), [])\n'
+        func_txt += f'        return ret\n'
+        func_txt += f'    except Exception as e:\n'
+        func_txt += f'        logger.error("Error occurs when tool is executed:", exc_info=True)\n'
+        func_txt += f'        raise e\n'
+        func_txt += f'func_ctx.append({func_name})\n'
+        return func_txt
+
+    def create_tools(self, logger:logging.Logger, args:argparse.Namespace) -> List[Any]:
+        """
+        ツールリストを作成します
+        
+        Args:
+            logger (logging.Logger): ロガー
+            args (argparse.Namespace): 引数
+        
+        Returns:
+            List[Any]: fastmcp.tools.FunctionToolのリスト
+        """
+        from fastmcp.tools import FunctionTool
+        options = Options.getInstance()
+        language, _ = locale.getlocale()
+        is_japan = language.find('Japan') >= 0 or language.find('ja_JP') >= 0
+        func_tools:List[FunctionTool] = []
+        for mode in options.get_mode_keys():
+            for cmd in options.get_cmd_keys(mode):
+                if not options.get_cmd_attr(mode, cmd, 'use_agent'):
+                    continue
+                # コマンドの説明と選択肢を取得
+                description = options.get_cmd_attr(mode, cmd, 'description_ja' if is_japan else 'description_en')
+                choices = options.get_cmd_choices(mode, cmd, False)
+                func_name = f"{mode}_{cmd}"
+                # 関数の定義を生成
+                func_txt  = self._create_func_txt(func_name, mode, cmd, is_japan, options)
+                if logger.level == logging.DEBUG:
+                    logger.debug(f"generating agent tool: {func_name}")
+                func_ctx = []
+                # 関数を実行してコンテキストに追加
+                exec(func_txt,
+                     dict(time=time,List=List, Path=Path, argparse=argparse, common=common, options=options, logging=logging, signin=signin,),
+                     dict(func_ctx=func_ctx))
+                # 関数のスキーマを生成
+                input_schema = dict(
+                    type="object",
+                    properties={o['opt']: self._to_schema(o, is_japan) for o in choices},
+                    required=[o['opt'] for o in choices if o['required']],
+                )
+                output_schema = dict(type="object", properties=dict())
+                func_tool = FunctionTool(fn=func_ctx[0], name=func_name, title=func_name.title(), description=description, 
+                                         tags=[f"mode={mode}", f"cmd={cmd}"],
+                                         parameters=input_schema, output_schema=output_schema,)
+                # ツールリストに追加
+                func_tools.append(func_tool)
+        return func_tools
+
+    def create_mw_toollist(self, logger:logging.Logger, args:argparse.Namespace) -> Any:
+        """
+        ツールリストを作成するミドルウェアを作成します
+
+        Args:
+            logger (logging.Logger): ロガー
+            args (argparse.Namespace): 引数
+
+        Returns:
+            Any: ミドルウェア
+        """
+        from cmdbox.app.web import Web
+        from fastmcp.server.middleware import Middleware, MiddlewareContext, ListToolsResult
+        from fastmcp.tools import FunctionTool
+        func_tools:List[FunctionTool] = self.create_tools(logger, args)
+        options = Options.getInstance()
+        cmd_list:feature.Feature = options.get_cmd_attr('cmd', 'list', "feature")
+        language, _ = locale.getlocale()
+        is_japan = language.find('Japan') >= 0 or language.find('ja_JP') >= 0
+        mcp = self
+        class CommandListMiddleware(Middleware):
+            async def on_list_tools(self, context: MiddlewareContext, call_next):
+                # 認証情報の取得
+                scope = signin.get_request_scope()
+                web:Web = scope["web"]
+                signin_file = web.signin_file
+                signin_data = signin.Signin.load_signin_file(signin_file)
+                if signin.Signin._check_signin(scope["req"], scope["res"], signin_data, logger) is not None:
+                    logger.warning("Unable to execute command because authentication information cannot be obtained")
+                    return dict(warn="Unable to execute command because authentication information cannot be obtained")
+                groups = scope["req"].session["signin"]["groups"]
+                ret_tools = []
+                # システムコマンドリストのフィルタリング
+                for func in func_tools:
+                    mode = [t.replace('mode=', '') for t in func.tags if t.startswith('mode=')]
+                    mode = mode[0] if mode else None
+                    cmd = [t.replace('cmd=', '') for t in func.tags if t.startswith('cmd=')]
+                    cmd = cmd[0] if cmd else None
+                    if mode is None or cmd is None:
+                        logger.warning(f"Tool {func.name} does not have mode or cmd tag, skipping.")
+                        continue
+                    if not signin.Signin._check_cmd(signin_data, groups, mode, cmd, logger):
+                        logger.warning(f"User does not have permission to use tool {func.name} (mode={mode}, cmd={cmd}), skipping.")
+                        continue
+                    ret_tools.append(func)
+                #　ユーザーコマンドリストの取得
+                args = argparse.Namespace(data=web.data, signin_file=signin_file, groups=groups, kwd=None,
+                                          format=False, output_json=None, output_json_append=False,)
+                st, ret, _ = cmd_list.apprun(logger, args, time.perf_counter(), [])
+                if ret is None or 'success' not in ret or not ret['success']:
+                    return ret_tools
+                for opt in ret['success']:
+                    func_name = f"user_{opt['title']}"
+                    mode, cmd, description = opt['mode'], opt['cmd'], opt['description'] if 'description' in opt and opt['description'] else ''
+                    choices = options.get_cmd_choices(mode, cmd, False)
+                    description += '\n' + options.get_cmd_attr(mode, cmd, 'description_ja' if is_japan else 'description_en')
+                    # 関数の定義を生成
+                    func_txt  = mcp._create_func_txt(func_name, mode, cmd, is_japan, options, title=opt['title'])
+                    if logger.level == logging.DEBUG:
+                        logger.debug(f"generating agent tool: {func_name}")
+                    func_ctx = []
+                    # 関数を実行してコンテキストに追加
+                    exec(func_txt,
+                        dict(time=time,List=List, Path=Path, argparse=argparse, common=common, options=options, logging=logging, signin=signin,),
+                        dict(func_ctx=func_ctx))
+                    # 関数のスキーマを生成
+                    input_schema = dict(
+                        type="object",
+                        properties={o['opt']: mcp._to_schema(o, is_japan) for o in choices},
+                        required=[],
+                    )
+                    output_schema = dict(type="object", properties=dict())
+                    func_tool = FunctionTool(fn=func_ctx[0], name=func_name, title=func_name.title(), description=description, 
+                                            tags=[f"mode={mode}", f"cmd={cmd}"],
+                                            parameters=input_schema, output_schema=output_schema,)
+                    # ツールリストに追加
+                    ret_tools.append(func_tool)
+
+                return ret_tools
+        return CommandListMiddleware()
+
+    def create_mw_logging(self, logger:logging.Logger, args:argparse.Namespace) -> Any:
+        """
+        ログ出力用のミドルウェアを作成します
+
+        Args:
+            logger (logging.Logger): ロガー
+            args (argparse.Namespace): 引数
+
+        Returns:
+            Any: ミドルウェア
+        """
+        from fastmcp.server.middleware import Middleware, MiddlewareContext
+        class LoggingMiddleware(Middleware):
+            async def on_message(self, context: MiddlewareContext, call_next):
+                if logger.level == logging.DEBUG:
+                    logger.debug(f"MCP Processing method=`{context.method}`, source=`{context.source}`, message=`{context.message}`")
+                try:
+                    result = await call_next(context)
+                    if logger.level == logging.DEBUG:
+                        logger.debug(f"MCP Complated method=`{context.method}`")
+                    return result
+                except Exception as e:
+                    logger.error(f"MCP Error method=`{context.method}`, source=`{context.source}`, message=`{context.message}`: {e}", exc_info=True)
+                    raise e
+        return LoggingMiddleware()
+
+    def create_mw_reqscope(self, logger:logging.Logger, args:argparse.Namespace, web) -> Any:
+        """
+        認証用のミドルウェアを作成します
+
+        Args:
+            logger (logging.Logger): ロガー
+            args (argparse.Namespace): 引数
+            web (Any): Web関連のオブジェクト
+
+        Returns:
+            Any: ミドルウェア
+        """
+        from fastapi import Response
+        from fastmcp.server.middleware import Middleware, MiddlewareContext
+        class ReqScopeMiddleware(Middleware):
+            async def on_message(self, context: MiddlewareContext, call_next):
+                signin.request_scope.set(dict(req=context.fastmcp_context.request_context.request, res=Response(), websocket=None, web=web))
+                result = await call_next(context)
+                return result
+        return ReqScopeMiddleware()
+
+    def init_agent_runner(self, logger:logging.Logger, args:argparse.Namespace, web:Any) -> Tuple[Any, Any]:
         """
         エージェントの初期化を行います
 
         Args:
             logger (logging.Logger): ロガー
             args (argparse.Namespace): 引数
+            web (Any): Web関連のオブジェクト
 
         Returns:
             Tuple[Any, Any]: ランナーとFastMCP
@@ -255,120 +560,11 @@ class Mcp:
         # モジュールインポート
         from fastmcp import FastMCP
         from google.adk.sessions import BaseSessionService
-        mcp:FastMCP = self.create_mcpserver(args)
         session_service:BaseSessionService = self.create_session_service(args)
-        options = Options.getInstance()
-        tools:Callable[[logging.Logger, argparse.Namespace, float, Dict], Tuple[int, Dict[str, Any], Any]] = []
-
-        def _ds(d:str) -> str:
-            return f'"{d}"' if d is not None else 'None'
-        def _t2s(o:Dict[str, Any], req=True) -> str:
-            t, m, d, r = o["type"], o["multi"], o["default"], o["required"]
-            if t == Options.T_BOOL: return ("List[bool]=[]" if m else f"bool={d}") if req else ("List[bool]" if m else f"bool")
-            if t == Options.T_DATE: return ("List[str]=[]" if m else f"str={_ds(d)}") if req else ("List[str]" if m else f"str")
-            if t == Options.T_DATETIME: return ("List[str]=[]" if m else f"str={_ds(d)}") if req else ("List[str]" if m else f"str")
-            if t == Options.T_DICT: return ("List[dict]=[]" if m else f"dict={d}") if req else ("List[dict]" if m else f"dict")
-            if t == Options.T_DIR or t == Options.T_FILE:
-                if d is not None: d = str(d).replace('\\', '/')
-                return ("List[str]=[]" if m else f"str={_ds(d)}") if req else ("List[str]" if m else f"str")
-            if t == Options.T_FLOAT: return ("List[float]=[]" if m else f"float={d}") if req else ("List[float]" if m else f"float")
-            if t == Options.T_INT: return ("List[int]=[]" if m else f"int={d}") if req else ("List[int]" if m else f"int")
-            if t == Options.T_STR: return ("List[str]=[]" if m else f"str={_ds(d)}") if req else ("List[str]" if m else f"str")
-            if t == Options.T_TEXT: return ("List[str]=[]" if m else f"str={_ds(d)}") if req else ("List[str]" if m else f"str")
-            raise ValueError(f"Unknown type: {t} for option {o['opt']}")
-        def _arg(o:Dict[str, Any], is_japan) -> str:
-            t, d = o["type"], o["default"]
-            s = f'        {o["opt"]}:'
-            if t == Options.T_DIR or t == Options.T_FILE:
-                d = str(d).replace("\\", "/")
-            s += f'{_t2s(o, False)}={d}:'
-            #s += f'Optional[{_t2s(o, False)}]={d}:'
-            s += f'{o["discription_ja"] if is_japan else o["discription_en"]}'
-            return s
-        def _coercion(a:argparse.Namespace, key:str, dval) -> str:
-            dval = f'opt["{key}"] if "{key}" in opt else ' + f'"{dval}"' if isinstance(dval, str) else dval
-            aval = args.__dict__[key] if hasattr(args, key) and args.__dict__[key] else None
-            aval = f'"{aval}"' if isinstance(aval, str) else aval
-            ret = f'opt["{key}"] = {aval}' if aval is not None else f'opt["{key}"] = {dval}'
-            return ret
-        language, _ = locale.getlocale()
-        is_japan = language.find('Japan') >= 0 or language.find('ja_JP') >= 0
-        for mode in options.get_mode_keys():
-            for cmd in options.get_cmd_keys(mode):
-                if not options.get_cmd_attr(mode, cmd, 'use_agent'):
-                    continue
-                discription = options.get_cmd_attr(mode, cmd, 'discription_ja' if is_japan else 'discription_en')
-                choices = options.get_cmd_choices(mode, cmd, False)
-                if len([opt for opt in choices if 'opt' in opt and opt['opt'] == 'signin_file']) <= 0:
-                    choices.append(dict(opt="signin_file", type=Options.T_FILE, default=f'.{self.ver.__appid__}/user_list.yml', required=True, multi=False, hide=True, choice=None,
-                        discription_ja="サインイン可能なユーザーとパスワードを記載したファイルを指定します。省略した時は認証を要求しません。",
-                        discription_en="Specify a file containing users and passwords with which they can signin. If omitted, no authentication is required."),)
-                fn = f"{mode}_{cmd}"
-                func_txt  = f'def {fn}(' + ", ".join([f'{o["opt"]}:{_t2s(o, False)}' for o in choices]) + '):\n'
-                func_txt += f'    """\n'
-                func_txt += f'    {discription}\n'
-                func_txt += f'    Args:\n'
-                func_txt += "\n".join([_arg(o, is_japan) for o in choices])
-                func_txt += f'\n'
-                func_txt += f'    Returns:\n'
-                func_txt += f'        Dict[str, Any]:{"処理結果" if is_japan else "Processing Result"}\n'
-                func_txt += f'    """\n'
-                func_txt += f'    scope = signin.get_request_scope()\n'
-                func_txt += f'    logger = common.default_logger()\n'
-                func_txt += f'    opt = dict()\n'
-                func_txt += f'    opt["mode"] = "{mode}"\n'
-                func_txt += f'    opt["cmd"] = "{cmd}"\n'
-                func_txt += f'    opt["data"] = opt["data"] if hasattr(opt, "data") else common.HOME_DIR / ".{self.ver.__appid__}"\n'
-                func_txt += f'    opt["format"] = False\n'
-                func_txt += f'    opt["output_json"] = None\n'
-                func_txt += f'    opt["output_json_append"] = False\n'
-                func_txt += f'    opt["debug"] = logger.level == logging.DEBUG\n'
-                func_txt += '\n'.join([f'    opt["{o["opt"]}"] = {o["opt"]}' for o in choices])+'\n'
-                func_txt += f'    {_coercion(args, "host", self.default_host)}\n'
-                func_txt += f'    {_coercion(args, "port", self.default_port)}\n'
-                func_txt += f'    {_coercion(args, "password", self.default_pass)}\n'
-                func_txt += f'    {_coercion(args, "svname", self.default_svname)}\n'
-                func_txt += f'    {_coercion(args, "retry_count", 3)}\n'
-                func_txt += f'    {_coercion(args, "retry_interval", 3)}\n'
-                func_txt += f'    {_coercion(args, "timeout", 15)}\n'
-                func_txt += f'    {_coercion(args, "output_json", None)}\n'
-                func_txt += f'    {_coercion(args, "output_json_append", False)}\n'
-                func_txt += f'    {_coercion(args, "stdout_log", False)}\n'
-                func_txt += f'    {_coercion(args, "capture_stdout", False)}\n'
-                func_txt += f'    {_coercion(args, "capture_maxsize", 1024*1024)}\n'
-                func_txt += f'    {_coercion(args, "tag", None)}\n'
-                func_txt += f'    {_coercion(args, "clmsg_id", None)}\n'
-                func_txt += f'    opt["signin_file"] = signin_file if signin_file else ".{self.ver.__appid__}/user_list.yml"\n'
-                func_txt += f'    args = argparse.Namespace(**opt)\n'
-                func_txt += f'    signin_data = signin.Signin.load_signin_file(args.signin_file)\n'
-                func_txt += f'    req = scope["req"] if scope["req"] is not None else scope["websocket"]\n'
-                func_txt += f'    sign = signin.Signin._check_signin(req, scope["res"], signin_data, logger)\n'
-                func_txt += f'    if sign is not None:\n'
-                func_txt += f'        logger.warning("Unable to execute command because authentication information cannot be obtained")\n'
-                func_txt += f'        return dict(warn="Unable to execute command because authentication information cannot be obtained")\n'
-                func_txt += f'    groups = req.session["signin"]["groups"]\n'
-                func_txt += f'    logger.info("Call agent tool `{mode}_{cmd}`:user="+str(req.session["signin"]["name"])+" groups="+str(groups)+" args="+str(args))\n'
-                func_txt += f'    if not signin.Signin._check_cmd(signin_data, groups, "{mode}", "{cmd}", logger):\n'
-                func_txt += f'        logger.warning("You do not have permission to execute this command.")\n'
-                func_txt += f'        return dict(warn="You do not have permission to execute this command.")\n'
-                func_txt += f'    feat = Options.getInstance().get_cmd_attr("{mode}", "{cmd}", "feature")\n'
-                func_txt += f'    try:\n'
-                func_txt += f'        st, ret, _ = feat.apprun(logger, args, time.perf_counter(), [])\n'
-                func_txt += f'        return ret\n'
-                func_txt += f'    except Exception as e:\n'
-                func_txt += f'        logger.error("Error occurs when tool is executed:", exc_info=True)\n'
-                func_txt += f'        raise e\n'
-                func_txt += f'tools.append({fn})\n'
-                if logger.level == logging.DEBUG:
-                    logger.debug(f"generating agent tool: {fn}")
-
-                exec(func_txt,
-                     dict(time=time,List=List, argparse=argparse, common=common, Options=Options, logging=logging, signin=signin,),
-                     dict(tools=tools, mcp=mcp))
-                exec(f"@mcp.tool\n{func_txt}",
-                     dict(time=time,List=List, argparse=argparse, common=common, Options=Options, logging=logging, signin=signin,),
-                     dict(tools=[], mcp=mcp))
-        root_agent = self.create_agent(logger, args, tools)
+        from fastmcp.tools import FunctionTool
+        tools:List[FunctionTool] = self.create_tools(logger, args)
+        mcp:FastMCP = self.create_mcpserver(args, tools, web)
+        root_agent = self.create_agent(logger, args, [t.fn for t in tools])
         runner = self.create_runner(logger, args, session_service, root_agent)
         if logger.level == logging.DEBUG:
             logger.debug(f"init_agent_runner complate.")

cmdbox/app/options.py

@@ -180,7 +180,7 @@ class Options:
             o = [f'-{val["short"]}'] if "short" in val else []
             o += [f'--{key}']
             language, _ = locale.getlocale()
-            opt['help'] = val['discription_en'] if language.find('Japan') < 0 and language.find('ja_JP') < 0 else val['discription_ja']
+            opt['help'] = val['description_en'] if language.find('Japan') < 0 and language.find('ja_JP') < 0 else val['description_ja']
             opt['default'] = val['default']
             if val['multi'] and val['default'] is not None:
                 raise ValueError(f'list_options: The default value must be None if multi is True. key={key}, val={val}')
@@ -256,49 +256,49 @@ class Options:
         self._options = dict()
         self._options["version"] = dict(
             short="v", type=Options.T_BOOL, default=None, required=False, multi=False, hide=True, choice=None,
-            discription_ja="バージョン表示",
-            discription_en="Display version")
+            description_ja="バージョン表示",
+            description_en="Display version")
         self._options["useopt"] = dict(
             short="u", type=Options.T_STR, default=None, required=False, multi=False, hide=True, choice=None,
-            discription_ja="オプションを保存しているファイルを使用します。",
-            discription_en="Use the file that saves the options.")
+            description_ja="オプションを保存しているファイルを使用します。",
+            description_en="Use the file that saves the options.")
         self._options["saveopt"] = dict(
             short="s", type=Options.T_BOOL, default=None, required=False, multi=False, hide=True, choice=[True, False],
-            discription_ja="指定しているオプションを `-u` で指定したファイルに保存します。",
-            discription_en="Save the specified options to the file specified by `-u`.")
+            description_ja="指定しているオプションを `-u` で指定したファイルに保存します。",
+            description_en="Save the specified options to the file specified by `-u`.")
         self._options["debug"] = dict(
             short="d", type=Options.T_BOOL, default=False, required=False, multi=False, hide=True, choice=[True, False],
-            discription_ja="デバックモードで起動します。",
-            discription_en="Starts in debug mode.")
+            description_ja="デバックモードで起動します。",
+            description_en="Starts in debug mode.")
         self._options["format"] = dict(
             short="f", type=Options.T_BOOL, default=None, required=False, multi=False, hide=True,
-            discription_ja="処理結果を見やすい形式で出力します。指定しない場合json形式で出力します。",
-            discription_en="Output the processing result in an easy-to-read format. If not specified, output in json format.",
+            description_ja="処理結果を見やすい形式で出力します。指定しない場合json形式で出力します。",
+            description_en="Output the processing result in an easy-to-read format. If not specified, output in json format.",
             choice=None)
         self._options["mode"] = dict(
             short="m", type=Options.T_STR, default=None, required=True, multi=False, hide=True,
-            discription_ja="起動モードを指定します。",
-            discription_en="Specify the startup mode.",
+            description_ja="起動モードを指定します。",
+            description_en="Specify the startup mode.",
             choice=[])
         self._options["cmd"] = dict(
             short="c", type=Options.T_STR, default=None, required=True, multi=False, hide=True,
-            discription_ja="コマンドを指定します。",
-            discription_en="Specify the command.",
+            description_ja="コマンドを指定します。",
+            description_en="Specify the command.",
             choice=[])
         self._options["tag"] = dict(
             short="t", type=Options.T_STR, default=None, required=False, multi=True, hide=True,
-            discription_ja="このコマンドのタグを指定します。",
-            discription_en="Specify the tag for this command.",
+            description_ja="このコマンドのタグを指定します。",
+            description_en="Specify the tag for this command.",
             choice=None)
         self._options["clmsg_id"] = dict(
             type=Options.T_STR, default=None, required=False, multi=False, hide=True,
-            discription_ja="クライアントのメッセージIDを指定します。省略した場合はuuid4で生成されます。",
-            discription_en="Specifies the message ID of the client. If omitted, uuid4 will be generated.",
+            description_ja="クライアントのメッセージIDを指定します。省略した場合はuuid4で生成されます。",
+            description_en="Specifies the message ID of the client. If omitted, uuid4 will be generated.",
             choice=None)
         self._options["description"] = dict(
             type=Options.T_TEXT, default=None, required=False, multi=False, hide=True,
-            discription_ja="このコマンド登録の説明文を指定します。Agentがこのコマンドの用途を理解するのに使用します。",
-            discription_en="Specifies a description of this command registration, used to help the Agent understand the use of this command.",
+            description_ja="このコマンド登録の説明文を指定します。Agentがこのコマンドの用途を理解するのに使用します。",
+            description_en="Specifies a description of this command registration, used to help the Agent understand the use of this command.",
             choice=None)
 
     def init_debugoption(self):

cmdbox/app/web.py

@@ -1,6 +1,6 @@
 from cmdbox.app import common, options
 from cmdbox.app.commons import module
-from fastapi import FastAPI, Request, Response
+from fastapi import FastAPI, Request, Response, WebSocket
 from pathlib import Path
 from starlette.applications import Starlette
 from starlette.middleware.sessions import SessionMiddleware

cmdbox/extensions/sample_project/sample/app/features/cli/sample_client_time.py

@@ -34,12 +34,12 @@ class ClientTime(feature.Feature):
         """
         return dict(
             type=Options.T_STR, default=None, required=False, multi=False, hide=False, use_redis=self.USE_REDIS_FALSE,
-            discription_ja="クライアント側の現在時刻を表示します。",
-            discription_en="Displays the current time at the client side.",
+            description_ja="クライアント側の現在時刻を表示します。",
+            description_en="Displays the current time at the client side.",
             choice=[
                 dict(opt="timedelta", type=Options.T_INT, default=9, required=False, multi=False, hide=False, choice=None,
-                        discription_ja="時差の時間数を指定します。",
-                        discription_en="Specify the number of hours of time difference."),
+                        description_ja="時差の時間数を指定します。",
+                        description_en="Specify the number of hours of time difference."),
             ])
 
     def apprun(self, logger:logging.Logger, args:argparse.Namespace, tm:float, pf:List[Dict[str, float]]=[]) -> Tuple[int, Dict[str, Any], Any]: