✨ Release/v1.7.5.1

Author: Phinease

backend/apps/model_managment_app.py

@@ -73,11 +73,11 @@ async def create_model(request: ModelRequest, authorization: Optional[str] = Hea
     except ValueError as e:
         logging.error(f"Failed to create model: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.CONFLICT,
-                            detail="Failed to create model: name conflict")
+                            detail=str(e))
     except Exception as e:
         logging.error(f"Failed to create model: {str(e)}")
         raise HTTPException(
-            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Failed to create model")
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))
 
 
 @router.post("/provider/create")
@@ -103,7 +103,7 @@ async def create_provider_model(request: ProviderModelRequest, authorization: Op
     except Exception as e:
         logging.error(f"Failed to create provider model: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to create provider model")
+                            detail=str(e))
 
 
 @router.post("/provider/batch_create")
@@ -129,7 +129,7 @@ async def batch_create_models(request: BatchCreateModelsRequest, authorization:
     except Exception as e:
         logging.error(f"Failed to batch create models: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to batch create models")
+                            detail=str(e))
 
 
 @router.post("/provider/list")
@@ -153,7 +153,7 @@ async def get_provider_list(request: ProviderModelRequest, authorization: Option
     except Exception as e:
         logging.error(f"Failed to get provider list: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to get provider list")
+                            detail=str(e))
 
 
 @router.post("/update")
@@ -179,11 +179,11 @@ async def update_single_model(request: dict, authorization: Optional[str] = Head
     except ValueError as e:
         logging.error(f"Failed to update model: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.CONFLICT,
-                            detail="Failed to update model: name conflict")
+                            detail=str(e))
     except Exception as e:
         logging.error(f"Failed to update model: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to update model")
+                            detail=str(e))
 
 
 @router.post("/batch_update")
@@ -203,7 +203,7 @@ async def batch_update_models(request: List[dict], authorization: Optional[str]
     except Exception as e:
         logging.error(f"Failed to batch update models: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to batch update models")
+                            detail=str(e))
 
 
 @router.post("/delete")
@@ -230,11 +230,11 @@ async def delete_model(display_name: str = Query(..., embed=True), authorization
     except LookupError as e:
         logging.error(f"Failed to delete model: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND,
-                            detail="Failed to delete model: model not found")
+                            detail=str(e))
     except Exception as e:
         logging.error(f"Failed to delete model: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to delete model")
+                            detail=str(e))
 
 
 @router.get("/list")
@@ -256,7 +256,7 @@ async def get_model_list(authorization: Optional[str] = Header(None)):
     except Exception as e:
         logging.error(f"Failed to list models: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to retrieve model list")
+                            detail=str(e))
 
 
 @router.get("/llm_list")
@@ -272,7 +272,7 @@ async def get_llm_model_list(authorization: Optional[str] = Header(None)):
     except Exception as e:
         logging.error(f"Failed to retrieve LLM list: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to retrieve LLM list")
+                            detail=str(e))
 
 
 @router.post("/healthcheck")
@@ -296,15 +296,15 @@ async def check_model_health(
     except LookupError as e:
         logging.error(f"Failed to check model connectivity: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND,
-                            detail="Model configuration not found")
+                            detail=str(e))
     except ValueError as e:
         logging.error(f"Invalid model configuration: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST,
-                            detail="Invalid model configuration")
+                            detail=str(e))
     except Exception as e:
         logging.error(f"Failed to check model connectivity: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to check model connectivity")
+                            detail=str(e))
 
 
 @router.post("/temporary_healthcheck")
@@ -324,4 +324,4 @@ async def check_temporary_model_health(request: ModelRequest):
     except Exception as e:
         logging.error(f"Failed to verify model connectivity: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            detail="Failed to verify model connectivity")
+                            detail=str(e))

backend/consts/const.py

@@ -265,4 +265,4 @@
     os.getenv("LLM_SLOW_TOKEN_RATE_THRESHOLD", "10.0"))  # tokens per second
 
 # APP Version
-APP_VERSION = "v1.7.4.1"
+APP_VERSION = "v1.7.5.1"

backend/consts/model.py

@@ -274,6 +274,10 @@ class ExportAndImportAgentInfo(BaseModel):
     enabled: bool
     tools: List[ToolConfig]
     managed_agents: List[int]
+    model_id: Optional[int] = None
+    model_name: Optional[str] = None
+    business_logic_model_id: Optional[int] = None
+    business_logic_model_name: Optional[str] = None
 
     class Config:
         arbitrary_types_allowed = True

backend/data_process/tasks.py

@@ -218,11 +218,11 @@ def process(
             logger.info(
                 f"[{self.request.id}] PROCESS TASK: Ray processing completed, got {len(chunks) if chunks else 0} chunks")
 
-            # Persist chunks into Redis via Ray (fire-and-forget, don't block)
+            # Persist chunks into Redis via Ray (synchronous to ensure data is ready before forward task)
             redis_key = f"dp:{task_id}:chunks"
             actor.store_chunks_in_redis.remote(redis_key, chunks)
             logger.info(
-                f"[{self.request.id}] PROCESS TASK: Scheduled store_chunks_in_redis for key '{redis_key}'")
+                f"[{self.request.id}] PROCESS TASK: Stored chunks in Redis at key '{redis_key}'")
 
             end_time = time.time()
             elapsed_time = end_time - start_time
@@ -252,11 +252,11 @@ def process(
             logger.info(
                 f"[{self.request.id}] PROCESS TASK: Ray processing completed, got {len(chunks) if chunks else 0} chunks")
 
-            # Persist chunks into Redis via Ray (fire-and-forget, don't block)
+            # Persist chunks into Redis via Ray (synchronous to ensure data is ready before forward task)
             redis_key = f"dp:{task_id}:chunks"
             actor.store_chunks_in_redis.remote(redis_key, chunks)
             logger.info(
-                f"[{self.request.id}] PROCESS TASK: Scheduled store_chunks_in_redis for key '{redis_key}'")
+                f"[{self.request.id}] PROCESS TASK: Stored chunks in Redis at key '{redis_key}'")
 
             end_time = time.time()
             elapsed_time = end_time - start_time

backend/database/db_models.py

@@ -257,7 +257,7 @@ class TenantConfig(TableBase):
     value_type = Column(String(
         100), doc=" the data type of config_value, optional values: single/multi", default="single")
     config_key = Column(String(100), doc="the key of the config")
-    config_value = Column(String(10000), doc="the value of the config")
+    config_value = Column(Text, doc="the value of the config")
 
 
 class MemoryUserConfig(TableBase):

backend/pyproject.toml

@@ -25,7 +25,7 @@ data-process = [
     "celery>=5.3.6",
     "flower>=2.0.1",
     "nest_asyncio>=1.5.6",
-    "unstructured[csv,docx,pdf,pptx,xlsx,md]"
+    "unstructured[csv,docx,pdf,pptx,xlsx,md]==0.18.14"
 ]
 test = [
     "pytest",

backend/services/agent_service.py

@@ -13,7 +13,7 @@
 from agents.agent_run_manager import agent_run_manager
 from agents.create_agent_info import create_agent_run_info, create_tool_config_list
 from agents.preprocess_manager import preprocess_manager
-from consts.const import MEMORY_SEARCH_START_MSG, MEMORY_SEARCH_DONE_MSG, MEMORY_SEARCH_FAIL_MSG, TOOL_TYPE_MAPPING, LANGUAGE, MESSAGE_ROLE
+from consts.const import MEMORY_SEARCH_START_MSG, MEMORY_SEARCH_DONE_MSG, MEMORY_SEARCH_FAIL_MSG, TOOL_TYPE_MAPPING, LANGUAGE, MESSAGE_ROLE, MODEL_CONFIG_MAPPING
 from consts.exceptions import MemoryPreparationException
 from consts.model import (
     AgentInfoRequest,
@@ -37,7 +37,7 @@
     search_blank_sub_agent_by_main_agent_id,
     update_agent
 )
-from database.model_management_db import get_model_by_model_id
+from database.model_management_db import get_model_by_model_id, get_model_id_by_display_name
 from database.remote_mcp_db import check_mcp_name_exists, get_mcp_server_by_name_and_tenant
 from database.tool_db import (
     check_tool_is_available,
@@ -52,6 +52,7 @@
 from services.remote_mcp_service import add_remote_mcp_server_list
 from services.tool_configuration_service import update_tool_list
 from utils.auth_utils import get_current_user_info, get_user_language
+from utils.config_utils import tenant_config_manager
 from utils.memory_utils import build_memory_config
 from utils.thread_utils import submit
 
@@ -82,6 +83,57 @@ def _resolve_user_tenant_language(
         return user_id, tenant_id, get_user_language(http_request)
 
 
+def _resolve_model_with_fallback(
+    model_display_name: str | None,
+    exported_model_id: str | None,
+    model_label: str,
+    tenant_id: str
+) -> str | None:
+    """
+    Resolve model_id from model_display_name with fallback to quick config LLM model.
+    
+    Args:
+        model_display_name: Display name of the model to lookup
+        exported_model_id: Original model_id from export (for logging only)
+        model_label: Label for logging (e.g., "Model", "Business logic model")
+        tenant_id: Tenant ID for model lookup
+    
+    Returns:
+        Resolved model_id or None if not found and no fallback available
+    """
+    if not model_display_name:
+        return None
+    
+    # Try to find model by display name in current tenant
+    resolved_id = get_model_id_by_display_name(model_display_name, tenant_id)
+    
+    if resolved_id:
+        logger.info(
+            f"{model_label} '{model_display_name}' found in tenant {tenant_id}, "
+            f"mapped to model_id: {resolved_id} (exported model_id was: {exported_model_id})")
+        return resolved_id
+    
+    # Model not found, try fallback to quick config LLM model
+    logger.warning(
+        f"{model_label} '{model_display_name}' (exported model_id: {exported_model_id}) "
+        f"not found in tenant {tenant_id}, falling back to quick config LLM model.")
+    
+    quick_config_model = tenant_config_manager.get_model_config(
+        key=MODEL_CONFIG_MAPPING["llm"],
+        tenant_id=tenant_id
+    )
+    
+    if quick_config_model:
+        fallback_id = quick_config_model.get("model_id")
+        logger.info(
+            f"Using quick config LLM model for {model_label.lower()}: "
+            f"{quick_config_model.get('display_name')} (model_id: {fallback_id})")
+        return fallback_id
+    
+    logger.warning(f"No quick config LLM model found for tenant {tenant_id}")
+    return None
+
+
 async def _stream_agent_chunks(
     agent_request: "AgentRequest",
     user_id: str,
@@ -429,6 +481,20 @@ async def export_agent_by_agent_id(agent_id: int, tenant_id: str, user_id: str)
         if tool.class_name == "KnowledgeBaseSearchTool":
             tool.metadata = {}
 
+    # Get model_id and model display name from agent_info
+    model_id = agent_info.get("model_id")
+    model_display_name = None
+    if model_id is not None:
+        model_info = get_model_by_model_id(model_id)
+        model_display_name = model_info.get("display_name") if model_info is not None else None
+
+    # Get business_logic_model_id and business logic model display name
+    business_logic_model_id = agent_info.get("business_logic_model_id")
+    business_logic_model_display_name = None
+    if business_logic_model_id is not None:
+        business_logic_model_info = get_model_by_model_id(business_logic_model_id)
+        business_logic_model_display_name = business_logic_model_info.get("display_name") if business_logic_model_info is not None else None
+
     agent_info = ExportAndImportAgentInfo(agent_id=agent_id,
                                           name=agent_info["name"],
                                           display_name=agent_info["display_name"],
@@ -444,7 +510,11 @@ async def export_agent_by_agent_id(agent_id: int, tenant_id: str, user_id: str)
                                               "few_shots_prompt"),
                                           enabled=agent_info["enabled"],
                                           tools=tool_list,
-                                          managed_agents=agent_relation_in_db)
+                                          managed_agents=agent_relation_in_db,
+                                          model_id=model_id,
+                                          model_name=model_display_name,
+                                          business_logic_model_id=business_logic_model_id,
+                                          business_logic_model_name=business_logic_model_display_name)
     return agent_info
 
 
@@ -565,12 +635,33 @@ async def import_agent_by_agent_id(import_agent_info: ExportAndImportAgentInfo,
     if not import_agent_info.name.isidentifier():
         raise ValueError(
             f"Invalid agent name: {import_agent_info.name}. agent name must be a valid python variable name.")
+    
+    # Resolve model IDs with fallback
+    # Note: We use model_display_name for cross-tenant compatibility
+    # The exported model_id is kept for reference/debugging only
+    model_id = _resolve_model_with_fallback(
+        model_display_name=import_agent_info.model_name,
+        exported_model_id=import_agent_info.model_id,
+        model_label="Model",
+        tenant_id=tenant_id
+    )
+    
+    business_logic_model_id = _resolve_model_with_fallback(
+        model_display_name=import_agent_info.business_logic_model_name,
+        exported_model_id=import_agent_info.business_logic_model_id,
+        model_label="Business logic model",
+        tenant_id=tenant_id
+    )
+
     # create a new agent
     new_agent = create_agent(agent_info={"name": import_agent_info.name,
                                          "display_name": import_agent_info.display_name,
                                          "description": import_agent_info.description,
                                          "business_description": import_agent_info.business_description,
-                                         "model_id": None,
+                                         "model_id": model_id,
+                                         "model_name": import_agent_info.model_name,
+                                         "business_logic_model_id": business_logic_model_id,
+                                         "business_logic_model_name": import_agent_info.business_logic_model_name,
                                          "max_steps": import_agent_info.max_steps,
                                          "provide_run_summary": import_agent_info.provide_run_summary,
                                          "duty_prompt": import_agent_info.duty_prompt,

backend/services/model_health_service.py

@@ -201,7 +201,7 @@ async def verify_model_config_connectivity(model_config: dict):
     Args:
         model_config: Model configuration dictionary, containing necessary connection parameters
     Returns:
-        dict: Contains the result of the connectivity test
+        dict: Contains the result of the connectivity test and error message if failed
     """
     try:
         model_name = model_config.get("model_name", "")
@@ -214,23 +214,34 @@ async def verify_model_config_connectivity(model_config: dict):
             connectivity = await _perform_connectivity_check(
                 model_name, model_type, model_base_url, model_api_key
             )
+            
+            if not connectivity:
+                return {
+                    "connectivity": False,
+                    "model_name": model_name,
+                    "error": f"Failed to connect to model '{model_name}' at {model_base_url}. Please verify the URL, API key, and network connection."
+                }
+            
+            return {
+                "connectivity": True,
+                "model_name": model_name,
+            }
         except ValueError as e:
-            logger.warning(f"UNCONNECTED: {model_name}; Base URL: {model_base_url}; API Key: {model_api_key}; Error: {str(e)}")
+            error_msg = str(e)
+            logger.warning(f"UNCONNECTED: {model_name}; Base URL: {model_base_url}; API Key: {model_api_key}; Error: {error_msg}")
             return {
                 "connectivity": False,
-                "model_name": model_name
+                "model_name": model_name,
+                "error": error_msg
             }
 
-        return {
-            "connectivity": connectivity,
-            "model_name": model_name,
-        }
-
     except Exception as e:
-        logger.error(f"Failed to check connectivity of models: {str(e)}")
+        error_msg = str(e)
+        logger.error(f"Failed to check connectivity of models: {error_msg}")
         return {
             "connectivity": False,
-            "model_name": model_config.get("model_name", "UNKNOWN_MODEL")
+            "model_name": model_config.get("model_name", "UNKNOWN_MODEL"),
+            "error": f"Connection verification failed: {error_msg}"
         }