update error handler

Author: CRZbulabula

integration-test/src/test/java/org/apache/iotdb/ainode/it/AINodeModelManageIT.java

@@ -75,6 +75,10 @@ public void userDefinedModelManagementTestInTree() throws SQLException, Interrup
       callInferenceTest(
           statement, new FakeModelInfo("user_chronos", "custom_t5", "user_defined", "active"));
       dropUserDefinedModel(statement);
+      errorTest(
+          statement,
+          "create model origin_chronos using uri \"file:///data/chronos2_origin\"",
+          "1505: 't5' is already used by a Transformers config, pick another name.");
     }
   }
 
@@ -86,6 +90,10 @@ public void userDefinedModelManagementTestInTable() throws SQLException, Interru
       forecastTableFunctionTest(
           statement, new FakeModelInfo("user_chronos", "custom_t5", "user_defined", "active"));
       dropUserDefinedModel(statement);
+      errorTest(
+          statement,
+          "create model origin_chronos using uri \"file:///data/chronos2_origin\"",
+          "1505: 't5' is already used by a Transformers config, pick another name.");
     }
   }
 

iotdb-core/ainode/iotdb/ainode/core/manager/model_manager.py

@@ -61,9 +61,13 @@ def register_model(
             return TRegisterModelResp(
                 get_status(TSStatusCode.CREATE_MODEL_ERROR, str(e))
             )
+        except Exception as e:
+            # Catch-all for other exceptions (mainly from transformers implementation)
+            return TRegisterModelResp(
+                get_status(TSStatusCode.CREATE_MODEL_ERROR, str(e))
+            )
 
     def show_models(self, req: TShowModelsReq) -> TShowModelsResp:
-        self._refresh()
         return self._model_storage.show_models(req)
 
     def delete_model(self, req: TDeleteModelReq) -> TSStatus:

iotdb-core/ainode/iotdb/ainode/core/model/model_storage.py

@@ -227,17 +227,22 @@ def _process_user_defined_model_directory(self, model_dir: str, model_id: str):
             model_type = config.get("model_type", "")
             auto_map = config.get("auto_map", None)
             pipeline_cls = config.get("pipeline_cls", "")
-
+        model_info = ModelInfo(
+            model_id=model_id,
+            model_type=model_type,
+            category=ModelCategory.USER_DEFINED,
+            state=ModelStates.ACTIVE,
+            pipeline_cls=pipeline_cls,
+            auto_map=auto_map,
+            transformers_registered=False,  # Lazy registration
+        )
+        with self._lock_pool.get_lock(model_id).write_lock():
+            self._models[ModelCategory.USER_DEFINED.value][model_id] = model_info
+        if self.ensure_transformers_registered(model_id) is None:
+            model_info.state = ModelStates.INACTIVE
+        else:
+            model_info.transformers_registered = True
         with self._lock_pool.get_lock(model_id).write_lock():
-            model_info = ModelInfo(
-                model_id=model_id,
-                model_type=model_type,
-                category=ModelCategory.USER_DEFINED,
-                state=ModelStates.ACTIVE,
-                pipeline_cls=pipeline_cls,
-                auto_map=auto_map,
-                transformers_registered=False,  # Lazy registration
-            )
             self._models[ModelCategory.USER_DEFINED.value][model_id] = model_info
 
     # ==================== Registration Methods ====================
@@ -254,6 +259,7 @@ def register_model(self, model_id: str, uri: str):
         Raises:
             ModelExistedException: If the model_id already exists.
             InvalidModelUriException: If the URI format is invalid.
+            Exception: For other errors during transformers model registration.
         """
 
         if self.is_model_registered(model_id):
@@ -291,25 +297,30 @@ def register_model(self, model_id: str, uri: str):
             )
             self._models[ModelCategory.USER_DEFINED.value][model_id] = model_info
 
-        if auto_map:
-            # Transformers model: immediately register to Transformers autoloading mechanism
-            success = self._register_transformers_model(model_info)
-            if success:
-                with self._lock_pool.get_lock(model_id).write_lock():
-                    model_info.transformers_registered = True
-            else:
-                with self._lock_pool.get_lock(model_id).write_lock():
+            if auto_map:
+                # Transformers model: immediately register to Transformers autoloading mechanism
+                try:
+                    if self._register_transformers_model(model_info):
+                        model_info.transformers_registered = True
+                except Exception as e:
                     model_info.state = ModelStates.INACTIVE
-                logger.error(f"Failed to register Transformers model {model_id}")
-        else:
-            # Other type models: only log
-            self._register_other_model(model_info)
+                    logger.error(
+                        f"Failed to register Transformers model {model_id}, because {e}"
+                    )
+                    raise e
+            else:
+                # Other type models: only log
+                self._register_other_model(model_info)
 
         logger.info(f"Successfully registered model {model_id} from URI: {uri}")
 
-    def _register_transformers_model(self, model_info: ModelInfo):
+    def _register_transformers_model(self, model_info: ModelInfo) -> bool:
         """
         Register Transformers model to autoloading mechanism (internal method)
+        Returns:
+            True if registration is successful
+        Raises:
+            Exception: Transformers internal exception if registration fails
         """
         auto_map = model_info.auto_map
         if not auto_map:
@@ -344,7 +355,7 @@ def _register_transformers_model(self, model_info: ModelInfo):
             logger.warning(
                 f"Failed to register Transformers model {model_info.model_id}: {e}. Model may still work via auto_map, but ensure module path is correct."
             )
-            return False
+            raise e
 
     def _register_other_model(self, model_info: ModelInfo):
         """Register other type models (non-Transformers models)"""
@@ -354,10 +365,9 @@ def _register_other_model(self, model_info: ModelInfo):
 
     def ensure_transformers_registered(self, model_id: str) -> ModelInfo | None:
         """
-        Ensure Transformers model is registered (called for lazy registration)
-        This method uses locks to ensure thread safety. All check logic is within lock protection.
+        Ensure Transformers model is registered.
         Returns:
-            str: If None, registration failed, otherwise returns model path
+            ModelInfo | None: None if registration failed, otherwise returns the corresponding ModelInfo
         """
         # Use lock to protect entire check-execute process
         with self._lock_pool.get_lock(model_id).write_lock():
@@ -385,8 +395,7 @@ def ensure_transformers_registered(self, model_id: str) -> ModelInfo | None:
 
             # Execute registration (under lock protection)
             try:
-                success = self._register_transformers_model(model_info)
-                if success:
+                if self._register_transformers_model(model_info):
                     model_info.transformers_registered = True
                     logger.info(
                         f"Model {model_id} successfully registered to Transformers"