🐛 no expected error should show on UI

Author: Phinease

backend/apps/model_managment_app.py

@@ -157,25 +157,35 @@ async def get_provider_list(request: ProviderModelRequest, authorization: Option
 
 
 @router.post("/update")
-async def update_single_model(request: dict, authorization: Optional[str] = Header(None)):
-    """Update a single model by its `model_id`.
+async def update_single_model(
+    request: dict,
+    display_name: str = Query(..., description="Current display name of the model to update"),
+    authorization: Optional[str] = Header(None)
+):
+    """Update a single model by its current `display_name`.
 
-    Performs a uniqueness check on `display_name` within the tenant and updates
-    the record if valid.
+    The model is looked up using the `display_name` query parameter. The request
+    body contains the fields to update, which may include a new `display_name`.
 
     Args:
-        request: Arbitrary model fields with required `model_id`.
+        request: Arbitrary model fields to update (may include new display_name).
+        display_name: Current display name of the model (query parameter for lookup).
         authorization: Bearer token header used to derive identity context.
 
     Raises:
-        HTTPException: 409 if `display_name` conflicts, 500 for unexpected errors.
+        HTTPException: 404 if model not found, 409 if new `display_name` conflicts,
+                       500 for unexpected errors.
     """
     try:
         user_id, tenant_id = get_current_user_id(authorization)
-        await update_single_model_for_tenant(user_id, tenant_id, request)
+        await update_single_model_for_tenant(user_id, tenant_id, display_name, request)
         return JSONResponse(status_code=HTTPStatus.OK, content={
             "message": "Model updated successfully"
         })
+    except LookupError as e:
+        logging.error(f"Failed to update model: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.NOT_FOUND,
+                            detail=str(e))
     except ValueError as e:
         logging.error(f"Failed to update model: {str(e)}")
         raise HTTPException(status_code=HTTPStatus.CONFLICT,

backend/database/model_management_db.py

@@ -185,6 +185,21 @@ def get_model_by_display_name(display_name: str, tenant_id: str) -> Optional[Dic
     return model
 
 
+def get_models_by_display_name(display_name: str, tenant_id: str) -> List[Dict[str, Any]]:
+    """
+    Get all model records by display name (for multi_embedding which creates two records)
+
+    Args:
+        display_name: Model display name
+        tenant_id: Tenant ID
+
+    Returns:
+        List[Dict[str, Any]]: List of model records with the same display_name
+    """
+    filters = {'display_name': display_name}
+    return get_model_records(filters, tenant_id)
+
+
 def get_model_id_by_display_name(display_name: str, tenant_id: str) -> Optional[int]:
     """
     Get a model ID by display name

backend/services/model_management_service.py

@@ -9,6 +9,7 @@
     create_model_record,
     delete_model_record,
     get_model_by_display_name,
+    get_models_by_display_name,
     get_model_records,
     get_models_by_tenant_factory_type,
     update_model_record,
@@ -198,20 +199,63 @@ async def list_provider_models_for_tenant(tenant_id: str, provider: str, model_t
         raise Exception(f"Failed to list provider models: {str(e)}")
 
 
-async def update_single_model_for_tenant(user_id: str, tenant_id: str, model_data: Dict[str, Any]):
-    """Update a single model by its model_id, ensuring display_name uniqueness."""
+async def update_single_model_for_tenant(
+    user_id: str,
+    tenant_id: str,
+    current_display_name: str,
+    model_data: Dict[str, Any]
+):
+    """Update model(s) by current display_name. If embedding/multi_embedding, update both types.
+
+    Args:
+        user_id: The user performing the update.
+        tenant_id: The tenant context.
+        current_display_name: The current display_name used to look up the model(s).
+        model_data: The fields to update, which may include a new display_name.
+
+    Raises:
+        LookupError: If no model is found with the current_display_name.
+        ValueError: If a new display_name conflicts with an existing model.
+    """
     try:
-        existing_model_by_display = get_model_by_display_name(model_data["display_name"], tenant_id)
-        current_model_id = int(model_data["model_id"])
-        existing_model_id = existing_model_by_display["model_id"] if existing_model_by_display else None
-        
-        if existing_model_by_display and existing_model_id != current_model_id:
-            raise ValueError(
-                f"Name {model_data['display_name']} is already in use, please choose another display name")
+        # Get all models with the current display_name (may be 1 or 2 for embedding types)
+        existing_models = get_models_by_display_name(current_display_name, tenant_id)
 
-        update_model_record(current_model_id, model_data, user_id)
-        logging.debug(
-            f"Model {model_data['display_name']} updated successfully")
+        if not existing_models:
+            raise LookupError(f"Model not found: {current_display_name}")
+
+        # Check if a new display_name is being set and if it conflicts
+        new_display_name = model_data.get("display_name")
+        if new_display_name and new_display_name != current_display_name:
+            conflict_models = get_models_by_display_name(new_display_name, tenant_id)
+            if conflict_models:
+                raise ValueError(
+                    f"Name {new_display_name} is already in use, please choose another display name"
+                )
+
+        # Check if any of the existing models is multi_embedding
+        has_multi_embedding = any(
+            m.get("model_type") == "multi_embedding" for m in existing_models
+        )
+
+        if has_multi_embedding:
+            # Update both embedding and multi_embedding records
+            for model in existing_models:
+                # Prepare update data, excluding model_type to preserve original type
+                update_data = {k: v for k, v in model_data.items() if k not in ["model_id", "model_type"]}
+                update_model_record(model["model_id"], update_data, user_id)
+            logging.debug(
+                f"Model {current_display_name} (embedding + multi_embedding) updated successfully")
+        else:
+            # Single model update
+            current_model_id = existing_models[0]["model_id"]
+            update_data = {k: v for k, v in model_data.items() if k != "model_id"}
+            update_model_record(current_model_id, update_data, user_id)
+            logging.debug(f"Model {current_display_name} updated successfully")
+    except LookupError:
+        raise
+    except ValueError:
+        raise
     except Exception as e:
         logging.error(f"Failed to update model: {str(e)}")
         raise Exception(f"Failed to update model: {str(e)}")
@@ -221,7 +265,7 @@ async def batch_update_models_for_tenant(user_id: str, tenant_id: str, model_lis
     """Batch update models for a tenant."""
     try:
         for model in model_list:
-            update_model_record(model["model_id"], model, user_id)
+            update_model_record(model["model_id"], model, user_id, tenant_id)
 
         logging.debug("Batch update models successfully")
     except Exception as e:
@@ -232,24 +276,24 @@ async def batch_update_models_for_tenant(user_id: str, tenant_id: str, model_lis
 async def delete_model_for_tenant(user_id: str, tenant_id: str, display_name: str):
     """Delete model(s) by display_name. If embedding/multi_embedding, delete both types."""
     try:
-        model = get_model_by_display_name(display_name, tenant_id)
-        if not model:
+        # Get all models with this display_name (may be 1 or 2 for embedding types)
+        models = get_models_by_display_name(display_name, tenant_id)
+        if not models:
             raise LookupError(f"Model not found: {display_name}")
 
         deleted_types: List[str] = []
-        if model.get("model_type") in ["embedding", "multi_embedding"]:
-            # Fetch both variants once to avoid repeated lookups
-            models_by_type: Dict[str, Dict[str, Any]] = {}
-            for t in ["embedding", "multi_embedding"]:
-                m = get_model_by_display_name(display_name, tenant_id)
-                if m and m.get("model_type") == t:
-                    models_by_type[t] = m
-
-            # Best-effort memory cleanup using the fetched variants
+        
+        # Check if any of the models is multi_embedding (which means we have both types)
+        has_multi_embedding = any(
+            m.get("model_type") == "multi_embedding" for m in models
+        )
+
+        if has_multi_embedding:
+            # Best-effort memory cleanup for embedding models
             try:
                 vdb_core = get_vector_db_core()
                 base_memory_config = build_memory_config_for_tenant(tenant_id)
-                for t, m in models_by_type.items():
+                for m in models:
                     try:
                         await clear_model_memories(
                             vdb_core=vdb_core,
@@ -270,17 +314,21 @@ async def delete_model_for_tenant(user_id: str, tenant_id: str, display_name: st
                 logger.warning(
                     "Memory cleanup preparation failed: %s", outer_cleanup_exc)
 
-            # Delete the fetched variants
-            for t, m in models_by_type.items():
+            # Delete all records with the same display_name
+            for m in models:
                 delete_model_record(m["model_id"], user_id, tenant_id)
-                deleted_types.append(t)
+                deleted_types.append(m.get("model_type", "unknown"))
         else:
+            # Single model delete
+            model = models[0]
             delete_model_record(model["model_id"], user_id, tenant_id)
             deleted_types.append(model.get("model_type", "unknown"))
 
         logging.debug(
             f"Successfully deleted model(s) in types: {', '.join(deleted_types)}")
         return display_name
+    except LookupError:
+        raise
     except Exception as e:
         logging.error(f"Failed to delete model: {str(e)}")
         raise Exception(f"Failed to delete model: {str(e)}")

frontend/app/[locale]/agents/components/tool/ToolPool.tsx

@@ -650,15 +650,19 @@ function ToolPool({
                 {t("toolPool.tooltip.functionGuide")}
               </div>
             }
-            overlayInnerStyle={{
-              backgroundColor: "#ffffff",
-              color: "#374151",
-              border: "1px solid #e5e7eb",
-              borderRadius: "6px",
-              boxShadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)",
-              padding: "12px",
-              maxWidth: "600px",
-              minWidth: "400px",
+            color="#ffffff"
+            styles={{
+              body: {
+                backgroundColor: "#ffffff",
+                color: "#374151",
+                border: "1px solid #e5e7eb",
+                borderRadius: "6px",
+                boxShadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)",
+                padding: "12px",
+                maxWidth: "800px",
+                minWidth: "700px",
+                width: "fit-content",
+              },
             }}
           >
             <BulbOutlined className="ml-2 text-yellow-500" />

frontend/app/[locale]/chat/streaming/taskWindow.tsx

@@ -967,6 +967,19 @@ export function TaskWindow({ messages, isStreaming = false }: TaskWindowProps) {
     );
   };
 
+  // Error messages that should be completely hidden (including the node)
+  const suppressedErrorMessages = [
+    "Model is interrupted by stop event",
+    "Agent execution interrupted by external stop signal",
+  ];
+
+  // Check if a message should be suppressed (not displayed at all)
+  const shouldSuppressMessage = (message: any) => {
+    if (message.type !== "error") return false;
+    const content = message.content || "";
+    return suppressedErrorMessages.some((errText) => content.includes(errText));
+  };
+
   // Check if it is the last message
   const isLastMessage = (index: number, messages: any[]) => {
     return index === messages.length - 1;
@@ -996,15 +1009,20 @@ export function TaskWindow({ messages, isStreaming = false }: TaskWindowProps) {
       );
     }
 
+    // Filter out messages that should be suppressed
+    const filteredGroupedMessages = groupedMessages.filter(
+      (group) => !shouldSuppressMessage(group.message)
+    );
+
     return (
       <div className="relative">
         <div className="absolute left-[0.2rem] top-[1.25rem] bottom-0 w-0.5 bg-gray-200"></div>
 
-        {groupedMessages.map((group, groupIndex) => {
+        {filteredGroupedMessages.map((group, groupIndex) => {
           const message = group.message;
           const isBlinking = shouldBlinkDot(
             groupIndex,
-            groupedMessages.map((g) => g.message)
+            filteredGroupedMessages.map((g) => g.message)
           );
 
           return (

frontend/app/[locale]/knowledges/KnowledgeBaseConfiguration.tsx

@@ -757,6 +757,40 @@ function DataConfig({ isActive }: DataConfigProps) {
     setNewKbName(name);
   };
 
+  // If Embedding model is not configured, show warning container instead of content
+  if (showEmbeddingWarning) {
+    return (
+      <div
+        className="w-full mx-auto relative"
+        style={{
+          maxWidth: SETUP_PAGE_CONTAINER.MAX_WIDTH,
+          padding: `0 ${SETUP_PAGE_CONTAINER.HORIZONTAL_PADDING}`,
+        }}
+      >
+        <div
+          className={STANDARD_CARD.BASE_CLASSES}
+          style={{
+            height: SETUP_PAGE_CONTAINER.MAIN_CONTENT_HEIGHT,
+            padding: STANDARD_CARD.PADDING,
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+          }}
+        >
+          <div className="text-center">
+            <WarningFilled
+              className="text-yellow-500 mb-4"
+              style={{ fontSize: 48 }}
+            />
+            <div className="text-base text-gray-800 font-semibold">
+              {t("embedding.knowledgeBaseDisabledWarningModal.title")}
+            </div>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
   return (
     <>
       <div
@@ -770,32 +804,6 @@ function DataConfig({ isActive }: DataConfigProps) {
         onDragLeave={handleDragLeave}
         onDrop={handleDrop}
       >
-        {showEmbeddingWarning && (
-          <div className="absolute inset-0 bg-gray-500/45 z-40" />
-        )}
-        <Modal
-          open={showEmbeddingWarning && !!contentRef.current}
-          title={null}
-          footer={null}
-          closable={false}
-          maskClosable={false}
-          mask={false}
-          centered
-          getContainer={() => contentRef.current || document.body}
-          styles={{ body: { padding: 0 } }}
-          rootClassName="kb-embedding-warning"
-        >
-          <div className="py-2">
-            <div className="flex items-center">
-              <WarningFilled className="text-yellow-500 mt-1 mr-2 text-3xl" />
-              <div className="ml-3 mt-2">
-                <div className="text-base text-gray-800 font-semibold">
-                  {t("embedding.knowledgeBaseDisabledWarningModal.title")}
-                </div>
-              </div>
-            </div>
-          </div>
-        </Modal>
         <Modal
           open={showAutoDeselectModal}
           title={t("embedding.knowledgeBaseAutoDeselectModal.title")}

frontend/app/[locale]/models/components/model/ModelAddDialog.tsx

@@ -1072,6 +1072,13 @@ export const ModelAddDialog = ({
             </div>
             <div className="mt-2 ml-6 flex items-center">
               <span>{t("model.dialog.label.currentlySupported")}</span>
+              <Tooltip title="ModelEngine">
+                <img
+                  src="/modelengine-logo.png"
+                  alt="ModelEngine"
+                  className="h-4 ml-1.5"
+                />
+              </Tooltip>
               {form.isBatchImport && (
                 <Tooltip title="SiliconFlow">
                   <img