Fix error handling in model and train handlers

- model list: wrap SDK calls in try/except for clean error output
- model/train: extract message from JSON-encoded API errors to prevent
  double-encoding in --json mode
- Add tests for error message extraction and model list 404 case

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: yeldarby

roboflow/cli/handlers/model.py

@@ -2,12 +2,31 @@
 
 from __future__ import annotations
 
+import json as _json
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import argparse
 
 
+def _extract_error_message(raw: str) -> str:
+    """Extract a human-readable message from a potentially JSON-encoded error string."""
+    text = raw.strip()
+    colon_idx = text.find(": {")
+    if colon_idx > 0 and colon_idx < 5:
+        text = text[colon_idx + 2 :]
+    try:
+        parsed = _json.loads(text)
+        if isinstance(parsed, dict):
+            err = parsed.get("error", parsed)
+            if isinstance(err, dict):
+                return str(err.get("message") or err.get("hint") or err)
+            return str(err)
+    except (ValueError, TypeError):
+        pass
+    return raw
+
+
 def register(subparsers: argparse._SubParsersAction) -> None:  # type: ignore[type-arg]
     """Register ``model`` subcommand and its verbs."""
     model_parser = subparsers.add_parser("model", help="Manage trained models")
@@ -96,11 +115,19 @@ def _list_models(args: argparse.Namespace) -> None:
         return
 
     api_key = args.api_key or None
-    rf = roboflow.Roboflow(api_key=api_key)
-    workspace = rf.workspace(workspace_url)
-    project = workspace.project(project_slug)
 
-    versions = project.versions()
+    try:
+        from roboflow.cli._output import suppress_sdk_output
+
+        with suppress_sdk_output(args):
+            rf = roboflow.Roboflow(api_key=api_key)
+            workspace = rf.workspace(workspace_url)
+            project = workspace.project(project_slug)
+            versions = project.versions()
+    except Exception as exc:
+        output_error(args, _extract_error_message(str(exc)), exit_code=3)
+        return
+
     models = []
     for v in versions:
         if v.model:
@@ -148,7 +175,7 @@ def _get_model(args: argparse.Namespace) -> None:
         else:
             data = rfapi.get_project(api_key, workspace_url, project_slug)
     except rfapi.RoboflowError as exc:
-        output_error(args, str(exc), exit_code=3)
+        output_error(args, _extract_error_message(str(exc)), exit_code=3)
         return
 
     output(args, data, text=json.dumps(data, indent=2, default=str))

roboflow/cli/handlers/train.py

@@ -2,12 +2,33 @@
 
 from __future__ import annotations
 
+import json as _json
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import argparse
 
 
+def _extract_error_message(raw: str) -> str:
+    """Extract a human-readable message from a potentially JSON-encoded error string."""
+    # Strip status code prefix like "404: {...}"
+    text = raw.strip()
+    colon_idx = text.find(": {")
+    if colon_idx > 0 and colon_idx < 5:
+        text = text[colon_idx + 2 :]
+
+    try:
+        parsed = _json.loads(text)
+        if isinstance(parsed, dict):
+            err = parsed.get("error", parsed)
+            if isinstance(err, dict):
+                return str(err.get("message") or err.get("hint") or err)
+            return str(err)
+    except (ValueError, TypeError):
+        pass
+    return raw
+
+
 def register(subparsers: argparse._SubParsersAction) -> None:  # type: ignore[type-arg]
     """Register ``train`` subcommand and its verbs."""
     train_parser = subparsers.add_parser("train", help="Train a model")
@@ -104,7 +125,7 @@ def _start(args: argparse.Namespace) -> None:
             epochs=args.epochs,
         )
     except rfapi.RoboflowError as exc:
-        output_error(args, str(exc))
+        output_error(args, _extract_error_message(str(exc)))
         return
 
     data = {

tests/cli/test_model_handler.py

@@ -203,5 +203,64 @@ def test_upload_no_project_errors(self, mock_rf_cls: MagicMock) -> None:
             _upload_model(args)
 
 
+class TestExtractErrorMessage(unittest.TestCase):
+    """Test _extract_error_message helper."""
+
+    def test_plain_string(self) -> None:
+        from roboflow.cli.handlers.model import _extract_error_message
+
+        self.assertEqual(_extract_error_message("something broke"), "something broke")
+
+    def test_json_with_nested_error(self) -> None:
+        from roboflow.cli.handlers.model import _extract_error_message
+
+        raw = '{"error": {"message": "Unsupported request"}}'
+        self.assertEqual(_extract_error_message(raw), "Unsupported request")
+
+    def test_json_with_string_error(self) -> None:
+        from roboflow.cli.handlers.model import _extract_error_message
+
+        raw = '{"error": "Not found"}'
+        self.assertEqual(_extract_error_message(raw), "Not found")
+
+
+class TestModelListError(unittest.TestCase):
+    """Test _list_models handles API errors cleanly."""
+
+    def _make_args(self, **kwargs: object) -> types.SimpleNamespace:
+        defaults = {
+            "json": True,
+            "api_key": "test-key",
+            "workspace": "test-ws",
+            "project": "nonexistent-project",
+        }
+        defaults.update(kwargs)
+        return types.SimpleNamespace(**defaults)
+
+    @patch("roboflow.Roboflow")
+    def test_list_models_project_not_found(self, mock_rf_cls: MagicMock) -> None:
+        from roboflow.cli.handlers.model import _list_models
+
+        mock_workspace = MagicMock()
+        mock_workspace.project.side_effect = RuntimeError("Project not found")
+        mock_rf = MagicMock()
+        mock_rf.workspace.return_value = mock_workspace
+        mock_rf_cls.return_value = mock_rf
+
+        args = self._make_args()
+        buf = io.StringIO()
+        old_stderr = sys.stderr
+        sys.stderr = buf
+        try:
+            with self.assertRaises(SystemExit) as ctx:
+                _list_models(args)
+            self.assertEqual(ctx.exception.code, 3)
+        finally:
+            sys.stderr = old_stderr
+
+        result = json.loads(buf.getvalue())
+        self.assertIn("error", result)
+
+
 if __name__ == "__main__":
     unittest.main()

tests/cli/test_train_handler.py

@@ -144,6 +144,28 @@ def test_start_no_api_key(self, _mock_key: MagicMock) -> None:
             _start(args)
         self.assertEqual(ctx.exception.code, 2)
 
+    @patch("roboflow.adapters.rfapi.start_version_training")
+    def test_start_json_error_not_double_encoded(self, mock_train: MagicMock) -> None:
+        from roboflow.adapters.rfapi import RoboflowError
+        from roboflow.cli.handlers.train import _start
+
+        # Simulate API returning a JSON error string
+        mock_train.side_effect = RoboflowError('{"error": {"message": "Unsupported request"}}')
+
+        args = self._make_args(json=True)
+        buf = io.StringIO()
+        old_stderr = sys.stderr
+        sys.stderr = buf
+        try:
+            with self.assertRaises(SystemExit):
+                _start(args)
+        finally:
+            sys.stderr = old_stderr
+
+        result = json.loads(buf.getvalue())
+        # Should be a clean string, not double-encoded JSON
+        self.assertEqual(result["error"], "Unsupported request")
+
 
 if __name__ == "__main__":
     unittest.main()