fix: wip 3372 left

Signed-off-by: yihong0618 <zouzou0208@gmail.com>

api/commands.py

@@ -555,7 +555,8 @@ def create_tenant(email: str, language: Optional[str] = None, name: Optional[str
     if language not in languages:
         language = "en-US"
 
-    name = name.strip()
+    if name is not None:
+        name = name.strip()
 
     # generate random password
     new_password = secrets.token_urlsafe(16)

api/controllers/console/app/wraps.py

@@ -9,7 +9,7 @@
 from models.model import AppMode
 
 
-def get_app_model(view: Optional[Callable] = None, *, mode: Union[AppMode, list[AppMode]] = None):
+def get_app_model(view: Optional[Callable] = None, *, mode: Union[AppMode, list[AppMode], None] = None):
     def decorator(view_func):
         @wraps(view_func)
         def decorated_view(*args, **kwargs):

api/core/agent/base_agent_runner.py

@@ -1,7 +1,6 @@
 import json
 import logging
 import uuid
-from collections.abc import Mapping, Sequence
 from datetime import datetime, timezone
 from typing import Optional, Union, cast
 
@@ -112,12 +111,14 @@ def __init__(
         db.session.close()
 
         # check if model supports stream tool call
+        # FIXME confirm here, model_instance is not None
+        assert model_instance is not None
         llm_model = cast(LargeLanguageModel, model_instance.model_type_instance)
         model_schema = llm_model.get_model_schema(model_instance.model, model_instance.credentials)
         features = model_schema.features if model_schema and model_schema.features else []
         self.stream_tool_call = ModelFeature.STREAM_TOOL_CALL in features
         self.files = application_generate_entity.files if ModelFeature.VISION in features else []
-        self.query = None
+        self.query = Optional[str]
         self._current_thoughts: list[PromptMessage] = []
 
     def _repack_app_generate_entity(
@@ -145,7 +146,7 @@ def _convert_tool_to_prompt_message_tool(self, tool: AgentToolEntity) -> tuple[P
 
         message_tool = PromptMessageTool(
             name=tool.tool_name,
-            description=tool_entity.description.llm,
+            description=tool_entity.description.llm if tool_entity.description else "",
             parameters={
                 "type": "object",
                 "properties": {},
@@ -167,7 +168,7 @@ def _convert_tool_to_prompt_message_tool(self, tool: AgentToolEntity) -> tuple[P
                 continue
             enum = []
             if parameter.type == ToolParameter.ToolParameterType.SELECT:
-                enum = [option.value for option in parameter.options]
+                enum = [option.value for option in parameter.options] if parameter.options else []
 
             message_tool.parameters["properties"][parameter.name] = {
                 "type": parameter_type,
@@ -187,8 +188,8 @@ def _convert_dataset_retriever_tool_to_prompt_message_tool(self, tool: DatasetRe
         convert dataset retriever tool to prompt message tool
         """
         prompt_tool = PromptMessageTool(
-            name=tool.identity.name,
-            description=tool.description.llm,
+            name=tool.identity.name if tool.identity else "unknown",
+            description=tool.description.llm if tool.description else "",
             parameters={
                 "type": "object",
                 "properties": {},
@@ -210,14 +211,14 @@ def _convert_dataset_retriever_tool_to_prompt_message_tool(self, tool: DatasetRe
 
         return prompt_tool
 
-    def _init_prompt_tools(self) -> tuple[Mapping[str, Tool], Sequence[PromptMessageTool]]:
+    def _init_prompt_tools(self) -> tuple[dict[str, Tool], list[PromptMessageTool]]:
         """
         Init tools
         """
         tool_instances = {}
         prompt_messages_tools = []
 
-        for tool in self.app_config.agent.tools if self.app_config.agent else []:
+        for tool in self.app_config.agent.tools or [] if self.app_config.agent else []:
             try:
                 prompt_tool, tool_entity = self._convert_tool_to_prompt_message_tool(tool)
             except Exception:
@@ -234,7 +235,8 @@ def _init_prompt_tools(self) -> tuple[Mapping[str, Tool], Sequence[PromptMessage
             # save prompt tool
             prompt_messages_tools.append(prompt_tool)
             # save tool entity
-            tool_instances[dataset_tool.identity.name] = dataset_tool
+            if dataset_tool.identity is not None:
+                tool_instances[dataset_tool.identity.name] = dataset_tool
 
         return tool_instances, prompt_messages_tools
 
@@ -258,7 +260,7 @@ def update_prompt_message_tool(self, tool: Tool, prompt_tool: PromptMessageTool)
                 continue
             enum = []
             if parameter.type == ToolParameter.ToolParameterType.SELECT:
-                enum = [option.value for option in parameter.options]
+                enum = [option.value for option in parameter.options] if parameter.options else []
 
             prompt_tool.parameters["properties"][parameter.name] = {
                 "type": parameter_type,

api/core/agent/cot_agent_runner.py

@@ -1,7 +1,7 @@
 import json
 from abc import ABC, abstractmethod
 from collections.abc import Generator
-from typing import Optional
+from typing import Optional, cast
 
 from core.agent.base_agent_runner import BaseAgentRunner
 from core.agent.entities import AgentScratchpadUnit
@@ -12,6 +12,7 @@
 from core.model_runtime.entities.message_entities import (
     AssistantPromptMessage,
     PromptMessage,
+    PromptMessageTool,
     ToolPromptMessage,
     UserPromptMessage,
 )
@@ -28,9 +29,9 @@ class CotAgentRunner(BaseAgentRunner, ABC):
     _ignore_observation_providers = ["wenxin"]
     _historic_prompt_messages: list[PromptMessage] | None = None
     _agent_scratchpad: list[AgentScratchpadUnit] | None = None
-    _instruction: str | None = None
+    _instruction: str = ""  # FIXME this must be str for now
     _query: str | None = None
-    _prompt_messages_tools: list[PromptMessage] | None = None
+    _prompt_messages_tools: list[PromptMessageTool] = []
 
     def run(
         self,
@@ -66,10 +67,10 @@ def run(
         tool_instances, self._prompt_messages_tools = self._init_prompt_tools()
 
         function_call_state = True
-        llm_usage = {"usage": None}
+        llm_usage: dict[str, Optional[LLMUsage]] = {"usage": None}
         final_answer = ""
 
-        def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
+        def increase_usage(final_llm_usage_dict: dict[str, Optional[LLMUsage]], usage: LLMUsage):
             if not final_llm_usage_dict["usage"]:
                 final_llm_usage_dict["usage"] = usage
             else:
@@ -124,7 +125,7 @@ def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
             if not chunks:
                 raise ValueError("failed to invoke llm")
 
-            usage_dict: dict = {}
+            usage_dict: dict[str, Optional[LLMUsage]] = {"usage": None}
             react_chunks = CotAgentOutputParser.handle_react_stream_output(chunks, usage_dict)
             scratchpad = AgentScratchpadUnit(
                 agent_response="",
@@ -144,25 +145,30 @@ def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
                 if isinstance(chunk, AgentScratchpadUnit.Action):
                     action = chunk
                     # detect action
-                    scratchpad.agent_response += json.dumps(chunk.model_dump())
+                    if scratchpad.agent_response is not None:
+                        scratchpad.agent_response += json.dumps(chunk.model_dump())
                     scratchpad.action_str = json.dumps(chunk.model_dump())
                     scratchpad.action = action
                 else:
-                    scratchpad.agent_response += chunk
-                    scratchpad.thought += chunk
+                    if scratchpad.agent_response is not None:
+                        scratchpad.agent_response += chunk
+                    if scratchpad.thought is not None:
+                        scratchpad.thought += chunk
                     yield LLMResultChunk(
                         model=self.model_config.model,
                         prompt_messages=prompt_messages,
                         system_fingerprint="",
                         delta=LLMResultChunkDelta(index=0, message=AssistantPromptMessage(content=chunk), usage=None),
                     )
-
-            scratchpad.thought = scratchpad.thought.strip() or "I am thinking about how to help you"
-            self._agent_scratchpad.append(scratchpad)
+            if scratchpad.thought is not None:
+                scratchpad.thought = scratchpad.thought.strip() or "I am thinking about how to help you"
+            if self._agent_scratchpad is not None:
+                self._agent_scratchpad.append(scratchpad)
 
             # get llm usage
             if "usage" in usage_dict:
-                increase_usage(llm_usage, usage_dict["usage"])
+                if usage_dict["usage"] is not None:
+                    increase_usage(llm_usage, usage_dict["usage"])
             else:
                 usage_dict["usage"] = LLMUsage.empty_usage()
 
@@ -171,9 +177,9 @@ def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
                 tool_name=scratchpad.action.action_name if scratchpad.action else "",
                 tool_input={scratchpad.action.action_name: scratchpad.action.action_input} if scratchpad.action else {},
                 tool_invoke_meta={},
-                thought=scratchpad.thought,
+                thought=scratchpad.thought or "",
                 observation="",
-                answer=scratchpad.agent_response,
+                answer=scratchpad.agent_response or "",
                 messages_ids=[],
                 llm_usage=usage_dict["usage"],
             )
@@ -214,7 +220,7 @@ def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
                         agent_thought=agent_thought,
                         tool_name=scratchpad.action.action_name,
                         tool_input={scratchpad.action.action_name: scratchpad.action.action_input},
-                        thought=scratchpad.thought,
+                        thought=scratchpad.thought or "",
                         observation={scratchpad.action.action_name: tool_invoke_response},
                         tool_invoke_meta={scratchpad.action.action_name: tool_invoke_meta.to_dict()},
                         answer=scratchpad.agent_response,
@@ -252,8 +258,8 @@ def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
             answer=final_answer,
             messages_ids=[],
         )
-
-        self.update_db_variables(self.variables_pool, self.db_variables_pool)
+        if self.variables_pool is not None and self.db_variables_pool is not None:
+            self.update_db_variables(self.variables_pool, self.db_variables_pool)
         # publish end event
         self.queue_manager.publish(
             QueueMessageEndEvent(
@@ -312,8 +318,9 @@ def _handle_invoke_action(
 
         # publish files
         for message_file_id, save_as in message_files:
-            if save_as:
-                self.variables_pool.set_file(tool_name=tool_call_name, value=message_file_id, name=save_as)
+            if save_as is not None and self.variables_pool:
+                # FIXME the save_as type is confusing, it should be a string or not
+                self.variables_pool.set_file(tool_name=tool_call_name, value=message_file_id, name=str(save_as))
 
             # publish message file
             self.queue_manager.publish(
@@ -387,8 +394,8 @@ def _organize_historic_prompt_messages(
             if isinstance(message, AssistantPromptMessage):
                 if not current_scratchpad:
                     current_scratchpad = AgentScratchpadUnit(
-                        agent_response=message.content,
-                        thought=message.content or "I am thinking about how to help you",
+                        agent_response=cast(str, message.content),
+                        thought=cast(str, message.content) or "I am thinking about how to help you",
                         action_str="",
                         action=None,
                         observation=None,
@@ -405,7 +412,7 @@ def _organize_historic_prompt_messages(
                         pass
             elif isinstance(message, ToolPromptMessage):
                 if current_scratchpad:
-                    current_scratchpad.observation = message.content
+                    current_scratchpad.observation = cast(str, message.content)
             elif isinstance(message, UserPromptMessage):
                 if scratchpads:
                     result.append(AssistantPromptMessage(content=self._format_assistant_message(scratchpads)))

api/core/agent/cot_chat_agent_runner.py

@@ -80,6 +80,7 @@ def _organize_prompt_messages(self) -> list[PromptMessage]:
             assistant_messages = []
         else:
             assistant_message = AssistantPromptMessage(content="")
+            assistant_message.content = ""  # FIXME: type check tell mypy that assistant_message.content is str
             for unit in agent_scratchpad:
                 if unit.is_final():
                     assistant_message.content += f"Final Answer: {unit.agent_response}"

api/core/agent/cot_completion_agent_runner.py

@@ -1,5 +1,5 @@
 import json
-from typing import Optional
+from typing import Optional, cast
 
 from core.agent.cot_agent_runner import CotAgentRunner
 from core.model_runtime.entities.message_entities import AssistantPromptMessage, PromptMessage, UserPromptMessage
@@ -11,7 +11,11 @@ def _organize_instruction_prompt(self) -> str:
         """
         Organize instruction prompt
         """
+        if self.app_config.agent is None:
+            raise ValueError("Agent configuration is not set")
         prompt_entity = self.app_config.agent.prompt
+        if prompt_entity is None:
+            raise ValueError("prompt entity is not set")
         first_prompt = prompt_entity.first_prompt
 
         system_prompt = (
@@ -33,7 +37,8 @@ def _organize_historic_prompt(self, current_session_messages: Optional[list[Prom
             if isinstance(message, UserPromptMessage):
                 historic_prompt += f"Question: {message.content}\n\n"
             elif isinstance(message, AssistantPromptMessage):
-                historic_prompt += message.content + "\n\n"
+                if message.content is not None:
+                    historic_prompt += cast(str, message.content) + "\n\n"
 
         return historic_prompt
 
@@ -50,7 +55,7 @@ def _organize_prompt_messages(self) -> list[PromptMessage]:
         # organize current assistant messages
         agent_scratchpad = self._agent_scratchpad
         assistant_prompt = ""
-        for unit in agent_scratchpad:
+        for unit in agent_scratchpad or []:
             if unit.is_final():
                 assistant_prompt += f"Final Answer: {unit.agent_response}"
             else:

api/core/agent/fc_agent_runner.py

@@ -67,6 +67,7 @@ def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
                 llm_usage.total_price += usage.total_price
 
         model_instance = self.model_instance
+        assert model_instance is not None
 
         while function_call_state and iteration_step <= max_iteration_steps:
             function_call_state = False
@@ -75,7 +76,7 @@ def increase_usage(final_llm_usage_dict: dict[str, LLMUsage], usage: LLMUsage):
                 # the last iteration, remove all tools
                 prompt_messages_tools = []
 
-            message_file_ids = []
+            message_file_ids: list[str] = []
             agent_thought = self.create_agent_thought(
                 message_id=message.id, message="", tool_name="", tool_input="", messages_ids=message_file_ids
             )
@@ -391,7 +392,7 @@ def _init_system_message(
 
         return prompt_messages
 
-    def _organize_user_query(self, query, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
+    def _organize_user_query(self, query: str, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
         """
         Organize user query
         """

api/core/agent/output_parser/cot_output_parser.py

@@ -38,7 +38,7 @@ def parse_action(json_str):
             except:
                 return json_str or ""
 
-        def extra_json_from_code_block(code_block) -> Generator[Union[dict, str], None, None]:
+        def extra_json_from_code_block(code_block) -> Generator[Union[str, AgentScratchpadUnit.Action], None, None]:
             code_blocks = re.findall(r"```(.*?)```", code_block, re.DOTALL)
             if not code_blocks:
                 return
@@ -67,15 +67,15 @@ def extra_json_from_code_block(code_block) -> Generator[Union[dict, str], None,
         for response in llm_response:
             if response.delta.usage:
                 usage_dict["usage"] = response.delta.usage
-            response = response.delta.message.content
-            if not isinstance(response, str):
+            response_content = response.delta.message.content
+            if not isinstance(response_content, str):
                 continue
 
             # stream
             index = 0
-            while index < len(response):
+            while index < len(response_content):
                 steps = 1
-                delta = response[index : index + steps]
+                delta = response_content[index : index + steps]
                 yield_delta = False
 
                 if delta == "`":

api/core/app/app_config/easy_ui_based_app/dataset/manager.py

@@ -1,3 +1,4 @@
+import uuid
 from typing import Optional
 
 from core.app.app_config.entities import DatasetEntity, DatasetRetrieveConfigEntity

api/core/app/app_config/easy_ui_based_app/prompt_template/manager.py

@@ -1,4 +1,5 @@
 from core.app.app_config.entities import (
+    AdvancedChatMessageEntity,
     AdvancedChatPromptTemplateEntity,
     AdvancedCompletionPromptTemplateEntity,
     PromptTemplateEntity,
@@ -25,7 +26,9 @@ def convert(cls, config: dict) -> PromptTemplateEntity:
                 chat_prompt_messages = []
                 for message in chat_prompt_config.get("prompt", []):
                     chat_prompt_messages.append(
-                        {"text": message["text"], "role": PromptMessageRole.value_of(message["role"])}
+                        AdvancedChatMessageEntity(
+                            **{"text": message["text"], "role": PromptMessageRole.value_of(message["role"])}
+                        )
                     )
 
                 advanced_chat_prompt_template = AdvancedChatPromptTemplateEntity(messages=chat_prompt_messages)