chore: apply ruff's pyflakes linter rules (#2420)

api/controllers/console/app/app.py

 
                 if not model_instance:
                     raise ProviderNotInitializeError(
-                        f"No Default System Reasoning Model available. Please configure "
-                        f"in the Settings -> Model Provider.")
+                        "No Default System Reasoning Model available. Please configure "
+                        "in the Settings -> Model Provider.")
                 else:
                     model_config_dict["model"]["provider"] = model_instance.provider
                     model_config_dict["model"]["name"] = model_instance.model

api/controllers/console/datasets/datasets.py

                                                                   args['indexing_technique'])
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
         elif args['info_list']['data_source_type'] == 'notion_import':
                                                                     args['indexing_technique'])
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
         else:

api/controllers/console/datasets/datasets_document.py

                 )
             except InvokeAuthorizationError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
 
                                                                       'English', dataset_id)
                 except LLMBadRequestError:
                     raise ProviderNotInitializeError(
-                        f"No Embedding Model available. Please configure a valid provider "
-                        f"in the Settings -> Model Provider.")
+                        "No Embedding Model available. Please configure a valid provider "
+                        "in the Settings -> Model Provider.")
                 except ProviderTokenNotInitError as ex:
                     raise ProviderNotInitializeError(ex.description)
 
                                                                   'English', dataset_id)
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
         elif dataset.data_source_type == 'notion_import':
                                                                     None, 'English', dataset_id)
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
         else:

api/controllers/console/datasets/datasets_segments.py

                 )
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
 
                 )
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
         try:
                 )
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
             # check segment

api/controllers/console/datasets/hit_testing.py

             raise ProviderModelCurrentlyNotSupportError()
         except LLMBadRequestError:
             raise ProviderNotInitializeError(
-                f"No Embedding Model or Reranking Model available. Please configure a valid provider "
-                f"in the Settings -> Model Provider.")
+                "No Embedding Model or Reranking Model available. Please configure a valid provider "
+                "in the Settings -> Model Provider.")
         except InvokeError as e:
             raise CompletionRequestError(e.description)
         except ValueError as e:

api/controllers/console/explore/parameter.py

         # get all tools
         tools = agent_config.get('tools', [])
         url_prefix = (current_app.config.get("CONSOLE_API_URL")
-                  + f"/console/api/workspaces/current/tool-provider/builtin/")
+                  + "/console/api/workspaces/current/tool-provider/builtin/")
         for tool in tools:
             keys = list(tool.keys())
             if len(keys) >= 4:

api/controllers/files/image_preview.py

         webapp_logo_file_id = custom_config.get('replace_webapp_logo') if custom_config is not None else None
 
         if not webapp_logo_file_id:
-            raise NotFound(f'webapp logo is not found')
+            raise NotFound('webapp logo is not found')
 
         try:
             generator, mimetype = FileService.get_public_image_preview(

api/controllers/files/tool_files.py

             )
 
             if not result:
-                raise NotFound(f'file is not found')
+                raise NotFound('file is not found')
             
             generator, mimetype = result
         except Exception:

api/controllers/service_api/app/app.py

         # get all tools
         tools = agent_config.get('tools', [])
         url_prefix = (current_app.config.get("CONSOLE_API_URL")
-                  + f"/console/api/workspaces/current/tool-provider/builtin/")
+                  + "/console/api/workspaces/current/tool-provider/builtin/")
         for tool in tools:
             keys = list(tool.keys())
             if len(keys) >= 4:

api/controllers/service_api/dataset/segment.py

                 )
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
         # validate args
                 )
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
 
                 )
             except LLMBadRequestError:
                 raise ProviderNotInitializeError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ProviderNotInitializeError(ex.description)
             # check segment

api/controllers/web/app.py

         # get all tools
         tools = agent_config.get('tools', [])
         url_prefix = (current_app.config.get("CONSOLE_API_URL")
-                  + f"/console/api/workspaces/current/tool-provider/builtin/")
+                  + "/console/api/workspaces/current/tool-provider/builtin/")
         for tool in tools:
             keys = list(tool.keys())
             if len(keys) >= 4:

api/core/app_runner/assistant_app_runner.py

         """
         app_record = db.session.query(App).filter(App.id == application_generate_entity.app_id).first()
         if not app_record:
-            raise ValueError(f"App not found")
+            raise ValueError("App not found")
 
         app_orchestration_config = application_generate_entity.app_orchestration_config_entity
 

api/core/app_runner/basic_app_runner.py

         """
         app_record = db.session.query(App).filter(App.id == application_generate_entity.app_id).first()
         if not app_record:
-            raise ValueError(f"App not found")
+            raise ValueError("App not found")
 
         app_orchestration_config = application_generate_entity.app_orchestration_config_entity
 

api/core/features/assistant_base_runner.py

                 result += f"result link: {response.message}. please tell user to check it."
             elif response.type == ToolInvokeMessage.MessageType.IMAGE_LINK or \
                  response.type == ToolInvokeMessage.MessageType.IMAGE:
-                result += f"image has been created and sent to user already, you should tell user to check it now."
+                result += "image has been created and sent to user already, you should tell user to check it now."
             else:
                 result += f"tool response: {response.message}."
 

api/core/features/assistant_cot_runner.py

 
                             message_file_ids = [message_file.id for message_file, _ in message_files]
                         except ToolProviderCredentialValidationError as e:
-                            error_response = f"Please check your tool provider credentials"
+                            error_response = "Please check your tool provider credentials"
                         except (
                             ToolNotFoundError, ToolNotSupportedError, ToolProviderNotFoundError
                         ) as e:
         next_iteration = agent_prompt_message.next_iteration
 
         if not isinstance(first_prompt, str) or not isinstance(next_iteration, str):
-            raise ValueError(f"first_prompt or next_iteration is required in CoT agent mode")
+            raise ValueError("first_prompt or next_iteration is required in CoT agent mode")
         
         # check instruction, tools, and tool_names slots
         if not first_prompt.find("{{instruction}}") >= 0:

api/core/features/assistant_fc_runner.py

                             message_file_ids.append(message_file.id)
                             
                     except ToolProviderCredentialValidationError as e:
-                        error_response = f"Please check your tool provider credentials"
+                        error_response = "Please check your tool provider credentials"
                     except (
                         ToolNotFoundError, ToolNotSupportedError, ToolProviderNotFoundError
                     ) as e:

api/core/index/vector_index/vector_index.py

             vector_type = self._dataset.index_struct_dict['type']
 
         if not vector_type:
-            raise ValueError(f"Vector store must be specified.")
+            raise ValueError("Vector store must be specified.")
 
         if vector_type == "weaviate":
             from core.index.vector_index.weaviate_vector_index import WeaviateConfig, WeaviateVectorIndex

api/core/model_manager.py

         :return: full response or stream response chunk generator result
         """
         if not isinstance(self.model_type_instance, LargeLanguageModel):
-            raise Exception(f"Model type instance is not LargeLanguageModel")
+            raise Exception("Model type instance is not LargeLanguageModel")
 
         self.model_type_instance = cast(LargeLanguageModel, self.model_type_instance)
         return self.model_type_instance.invoke(
         :return: embeddings result
         """
         if not isinstance(self.model_type_instance, TextEmbeddingModel):
-            raise Exception(f"Model type instance is not TextEmbeddingModel")
+            raise Exception("Model type instance is not TextEmbeddingModel")
 
         self.model_type_instance = cast(TextEmbeddingModel, self.model_type_instance)
         return self.model_type_instance.invoke(
         :return: rerank result
         """
         if not isinstance(self.model_type_instance, RerankModel):
-            raise Exception(f"Model type instance is not RerankModel")
+            raise Exception("Model type instance is not RerankModel")
 
         self.model_type_instance = cast(RerankModel, self.model_type_instance)
         return self.model_type_instance.invoke(
         :return: false if text is safe, true otherwise
         """
         if not isinstance(self.model_type_instance, ModerationModel):
-            raise Exception(f"Model type instance is not ModerationModel")
+            raise Exception("Model type instance is not ModerationModel")
 
         self.model_type_instance = cast(ModerationModel, self.model_type_instance)
         return self.model_type_instance.invoke(
         :return: text for given audio file
         """
         if not isinstance(self.model_type_instance, Speech2TextModel):
-            raise Exception(f"Model type instance is not Speech2TextModel")
+            raise Exception("Model type instance is not Speech2TextModel")
 
         self.model_type_instance = cast(Speech2TextModel, self.model_type_instance)
         return self.model_type_instance.invoke(
         :return: text for given audio file
         """
         if not isinstance(self.model_type_instance, TTSModel):
-            raise Exception(f"Model type instance is not TTSModel")
+            raise Exception("Model type instance is not TTSModel")
 
         self.model_type_instance = cast(TTSModel, self.model_type_instance)
         return self.model_type_instance.invoke(

api/core/model_runtime/callbacks/logging_callback.py

         """
         self.print_text("\n[on_llm_before_invoke]\n", color='blue')
         self.print_text(f"Model: {model}\n", color='blue')
-        self.print_text(f"Parameters:\n", color='blue')
+        self.print_text("Parameters:\n", color='blue')
         for key, value in model_parameters.items():
             self.print_text(f"\t{key}: {value}\n", color='blue')
 
             self.print_text(f"\tstop: {stop}\n", color='blue')
 
         if tools:
-            self.print_text(f"\tTools:\n", color='blue')
+            self.print_text("\tTools:\n", color='blue')
             for tool in tools:
                 self.print_text(f"\t\t{tool.name}\n", color='blue')
 
         if user:
             self.print_text(f"User: {user}\n", color='blue')
 
-        self.print_text(f"Prompt messages:\n", color='blue')
+        self.print_text("Prompt messages:\n", color='blue')
         for prompt_message in prompt_messages:
             if prompt_message.name:
                 self.print_text(f"\tname: {prompt_message.name}\n", color='blue')
         self.print_text(f"Content: {result.message.content}\n", color='yellow')
 
         if result.message.tool_calls:
-            self.print_text(f"Tool calls:\n", color='yellow')
+            self.print_text("Tool calls:\n", color='yellow')
             for tool_call in result.message.tool_calls:
                 self.print_text(f"\t{tool_call.id}\n", color='yellow')
                 self.print_text(f"\t{tool_call.function.name}\n", color='yellow')

api/core/model_runtime/model_providers/baichuan/llm/llm.py

                  stop: List[str] | None = None, stream: bool = True, user: str | None = None) \
             -> LLMResult | Generator:
         if tools is not None and len(tools) > 0:
-            raise InvokeBadRequestError(f"Baichuan model doesn't support tools")
+            raise InvokeBadRequestError("Baichuan model doesn't support tools")
         
         instance = BaichuanModel(
             api_key=credentials['api_key'],

api/core/model_runtime/model_providers/openai_api_compatible/llm/llm.py

             try:
                 json_result = response.json()
             except json.JSONDecodeError as e:
-                raise CredentialsValidateFailedError(f'Credentials validation failed: JSON decode error')
+                raise CredentialsValidateFailedError('Credentials validation failed: JSON decode error')
 
             if (completion_type is LLMMode.CHAT
                     and ('object' not in json_result or json_result['object'] != 'chat.completion')):
                 raise CredentialsValidateFailedError(
-                    f'Credentials validation failed: invalid response object, must be \'chat.completion\'')
+                    'Credentials validation failed: invalid response object, must be \'chat.completion\'')
             elif (completion_type is LLMMode.COMPLETION
                   and ('object' not in json_result or json_result['object'] != 'text_completion')):
                 raise CredentialsValidateFailedError(
-                    f'Credentials validation failed: invalid response object, must be \'text_completion\'')
+                    'Credentials validation failed: invalid response object, must be \'text_completion\'')
         except CredentialsValidateFailedError:
             raise
         except Exception as ex:

api/core/model_runtime/model_providers/openai_api_compatible/text_embedding/text_embedding.py

             try:
                 json_result = response.json()
             except json.JSONDecodeError as e:
-                raise CredentialsValidateFailedError(f'Credentials validation failed: JSON decode error')
+                raise CredentialsValidateFailedError('Credentials validation failed: JSON decode error')
 
             if 'model' not in json_result:
                 raise CredentialsValidateFailedError(
-                    f'Credentials validation failed: invalid response')
+                    'Credentials validation failed: invalid response')
         except CredentialsValidateFailedError:
             raise
         except Exception as ex:

api/core/model_runtime/model_providers/wenxin/llm/ernie_bot.py

         # so, we just disable function calling for now.
 
         if tools is not None and len(tools) > 0:
-            raise BadRequestError(f'function calling is not supported yet.')
+            raise BadRequestError('function calling is not supported yet.')
 
         if stop is not None:
             if len(stop) > 4:
-                raise BadRequestError(f'stop list should not exceed 4 items.')
+                raise BadRequestError('stop list should not exceed 4 items.')
 
             for s in stop:
                 if len(s) > 20:
-                    raise BadRequestError(f'stop item should not exceed 20 characters.')
+                    raise BadRequestError('stop item should not exceed 20 characters.')
         
     def _build_request_body(self, model: str, messages: List[ErnieMessage], stream: bool, parameters: Dict[str, Any],
                             tools: List[PromptMessageTool], stop: List[str], user: str) -> Dict[str, Any]:
                                                 stop: List[str], user: str) \
         -> Dict[str, Any]:
         if len(messages) % 2 == 0:
-            raise BadRequestError(f'The number of messages should be odd.')
+            raise BadRequestError('The number of messages should be odd.')
         if messages[0].role == 'function':
-            raise BadRequestError(f'The first message should be user message.')
+            raise BadRequestError('The first message should be user message.')
         
         """
         TODO: implement function calling
                                  parameters: Dict[str, Any], stop: List[str], user: str) \
         -> Dict[str, Any]:
         if len(messages) == 0:
-            raise BadRequestError(f'The number of messages should not be zero.')
+            raise BadRequestError('The number of messages should not be zero.')
         
         # check if the first element is system, shift it
         system_message = ''
             system_message = message.content
 
         if len(messages) % 2 == 0:
-            raise BadRequestError(f'The number of messages should be odd.')
+            raise BadRequestError('The number of messages should be odd.')
         if messages[0].role != 'user':
-            raise BadRequestError(f'The first message should be user message.')
+            raise BadRequestError('The first message should be user message.')
         body = {
             'messages': [message.to_dict() for message in messages],
             'stream': stream,

api/core/model_runtime/model_providers/zhipuai/zhipuai_sdk/_client.py

         if base_url is None:
             base_url = os.environ.get("ZHIPUAI_BASE_URL")
         if base_url is None:
-            base_url = f"https://open.bigmodel.cn/api/paas/v4"
+            base_url = "https://open.bigmodel.cn/api/paas/v4"
         from .__version__ import __version__
         super().__init__(
             version=__version__,

api/core/prompt/output_parser/rule_config_generator.py

                 raise ValueError("Expected 'prompt' to be a string.")
             if not isinstance(parsed["variables"], list):
                 raise ValueError(
-                    f"Expected 'variables' to be a list."
+                    "Expected 'variables' to be a list."
                 )
             if not isinstance(parsed["opening_statement"], str):
                 raise ValueError(
-                    f"Expected 'opening_statement' to be a str."
+                    "Expected 'opening_statement' to be a str."
                 )
             return parsed
         except Exception as e:

api/core/tools/model/tool_model_manager.py

         )
 
         if not model_instance:
-            raise InvokeModelError(f'Model not found')
+            raise InvokeModelError('Model not found')
         
         llm_model = cast(LargeLanguageModel, model_instance.model_type_instance)
         schema = llm_model.get_model_schema(model_instance.model, model_instance.credentials)
 
         if not schema:
-            raise InvokeModelError(f'No model schema found')
+            raise InvokeModelError('No model schema found')
 
         max_tokens = schema.model_properties.get(ModelPropertyKey.CONTEXT_SIZE, None)
         if max_tokens is None:
         )
 
         if not model_instance:
-            raise InvokeModelError(f'Model not found')
+            raise InvokeModelError('Model not found')
         
         llm_model = cast(LargeLanguageModel, model_instance.model_type_instance)
 
         except InvokeConnectionError as e:
             raise InvokeModelError(f'Invoke connection error: {e}')
         except InvokeAuthorizationError as e:
-            raise InvokeModelError(f'Invoke authorization error')
+            raise InvokeModelError('Invoke authorization error')
         except InvokeServerUnavailableError as e:
             raise InvokeModelError(f'Invoke server unavailable error: {e}')
         except Exception as e:

api/core/tools/provider/builtin/yahoo/tools/analytics.py

         try:
             return self.create_text_message(str(summary_df.to_dict()))
         except (HTTPError, ReadTimeout):
-            return self.create_text_message(f'There is a internet connection problem. Please try again later.')
+            return self.create_text_message('There is a internet connection problem. Please try again later.')
     

api/core/tools/provider/builtin/yahoo/tools/news.py

         try:
             return self.run(ticker=query, user_id=user_id)
         except (HTTPError, ReadTimeout):
-            return self.create_text_message(f'There is a internet connection problem. Please try again later.')
+            return self.create_text_message('There is a internet connection problem. Please try again later.')
 
     def run(self, ticker: str, user_id: str) -> ToolInvokeMessage:
         company = yfinance.Ticker(ticker)

api/core/tools/provider/builtin/yahoo/tools/ticker.py

         try:
             return self.create_text_message(self.run(ticker=query))
         except (HTTPError, ReadTimeout):
-            return self.create_text_message(f'There is a internet connection problem. Please try again later.')
+            return self.create_text_message('There is a internet connection problem. Please try again later.')
     
     def run(self, ticker: str) -> str:
         return str(Ticker(ticker).info)

api/core/tools/tool/tool.py

                 result += f"result link: {response.message}. please tell user to check it."
             elif response.type == ToolInvokeMessage.MessageType.IMAGE_LINK or \
                  response.type == ToolInvokeMessage.MessageType.IMAGE:
-                result += f"image has been created and sent to user already, you should tell user to check it now."
+                result += "image has been created and sent to user already, you should tell user to check it now."
             elif response.type == ToolInvokeMessage.MessageType.BLOB:
                 if len(response.message) > 114:
                     result += str(response.message[:114]) + '...'

api/libs/helper.py

             datetime.strptime(value, self.format)
         except ValueError:
             error = ('Invalid {arg}: {val}. {arg} must be conform to the format {format}'
-                     .format(arg=self.argument, val=value, lo=self.format))
+                     .format(arg=self.argument, val=value, format=self.format))
             raise ValueError(error)
 
         return value

api/pyproject.toml

 [tool.ruff.lint]
 ignore-init-module-imports = true
 select = [
-    "F401", # unused-import
+    "F", # pyflakes rules
     "I001", # unsorted-imports
     "I002", # missing-required-import
-    "F811", # redefined-while-unused
+]
+ignore = [
+    "F403", # undefined-local-with-import-star
+    "F405", # undefined-local-with-import-star-usage
+    "F821", # undefined-name
+    "F841", # unused-variable
 ]

api/services/dataset_service.py

                 )
             except LLMBadRequestError:
                 raise ValueError(
-                    f"No Embedding Model available. Please configure a valid provider "
-                    f"in the Settings -> Model Provider.")
+                    "No Embedding Model available. Please configure a valid provider "
+                    "in the Settings -> Model Provider.")
             except ProviderTokenNotInitError as ex:
                 raise ValueError(f"The dataset in unavailable, due to: "
                                  f"{ex.description}")
                     filtered_data['collection_binding_id'] = dataset_collection_binding.id
                 except LLMBadRequestError:
                     raise ValueError(
-                        f"No Embedding Model available. Please configure a valid provider "
-                        f"in the Settings -> Model Provider.")
+                        "No Embedding Model available. Please configure a valid provider "
+                        "in the Settings -> Model Provider.")
                 except ProviderTokenNotInitError as ex:
                     raise ValueError(ex.description)
 

api/services/tools_manage_service.py

             :param provider: the provider dict
         """
         url_prefix = (current_app.config.get("CONSOLE_API_URL")
-                      + f"/console/api/workspaces/current/tool-provider/builtin/")
+                      + "/console/api/workspaces/current/tool-provider/builtin/")
         
         if 'icon' in provider:
             if provider['type'] == UserToolProvider.ProviderType.BUILTIN.value:
         tool_bundles, schema_type = ToolManageService.convert_schema_to_tool_bundles(schema, extra_info)
         
         if len(tool_bundles) > 10:
-            raise ValueError(f'the number of apis should be less than 10')
+            raise ValueError('the number of apis should be less than 10')
 
         # create db provider
         db_provider = ApiToolProvider(
             # try to parse schema, avoid SSRF attack
             ToolManageService.parser_api_schema(schema)
         except Exception as e:
-            raise ValueError(f'invalid schema, please check the url you provided')
+            raise ValueError('invalid schema, please check the url you provided')
         
         return {
             'schema': schema
         try:
             tool_bundles, _ = ApiBasedToolSchemaParser.auto_parse_to_tool_bundle(schema)
         except Exception as e:
-            raise ValueError(f'invalid schema')
+            raise ValueError('invalid schema')
         
         # get tool bundle
         tool_bundle = next(filter(lambda tb: tb.operation_id == tool_name, tool_bundles), None)