Handle connection error gracefully

Author: Tjaz Erzen

codeplain_REST_api.py

@@ -2,14 +2,14 @@
 from typing import Optional
 
 import requests
+from requests.exceptions import ConnectionError, Timeout
 
 import plain2code_exceptions
 from plain2code_state import RunState
 
 MAX_RETRIES = 4
 RETRY_DELAY = 3
 
-# TODO: Handle connection errors
 RETRY_ERROR_CODES = [
     "LLMInternalError",
 ]
@@ -76,7 +76,23 @@ def post_request(self, endpoint_url, headers, payload, run_state: Optional[RunSt
                 response.raise_for_status()
                 return response_json
 
+            except (ConnectionError, Timeout) as e:
+                # Network-related errors should always be retried
+                if attempt < MAX_RETRIES:
+                    self.console.info(f"Network error on attempt {attempt + 1}/{MAX_RETRIES + 1}: {e}")
+                    self.console.info(f"Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                    # Exponential backoff
+                    retry_delay *= 2
+                else:
+                    self.console.error(f"Max retries ({MAX_RETRIES}) exceeded. Network connection failed.")
+                    self.console.error(f"Last error: {str(e)}")
+                    raise plain2code_exceptions.NetworkConnectionError(
+                        f"Failed to connect to API server after {MAX_RETRIES + 1} attempts. "
+                    )
+
             except Exception as e:
+                # For other errors, check if they should be retried
                 if response_json is not None and "error_code" in response_json:
                     if response_json["error_code"] not in RETRY_ERROR_CODES:
                         raise e

plain2code.py

@@ -26,6 +26,7 @@
     MissingAPIKey,
     MissingPreviousFunctionalitiesError,
     MissingResource,
+    NetworkConnectionError,
     PlainSyntaxError,
     UnexpectedState,
 )
@@ -288,6 +289,11 @@ def main():  # noqa: C901
         exc_info = sys.exc_info()
         console.error(f"Missing resource: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
+    except NetworkConnectionError as e:
+        exc_info = sys.exc_info()
+        console.error(f"Connection error: {str(e)}\n")
+        console.error("Please check that your internet connection is working.")
+        console.debug(f"Render ID: {run_state.render_id}")
     except Exception as e:
         exc_info = sys.exc_info()
         console.error(f"Error rendering plain code: {str(e)}\n")

plain2code_exceptions.py

@@ -59,3 +59,9 @@ class MissingPreviousFunctionalitiesError(Exception):
     """Raised when trying to render from a FRID but previous FRID commits are missing."""
 
     pass
+
+
+class NetworkConnectionError(Exception):
+    """Raised when there is a network connectivity issue with the API server."""
+
+    pass

tui/plain2code_tui.py

@@ -19,7 +19,7 @@
     RenderModuleStarted,
     RenderStateUpdated,
 )
-from plain2code_exceptions import InternalServerError
+from plain2code_exceptions import InternalServerError, NetworkConnectionError
 from render_machine.states import States
 from tui.widget_helpers import log_to_widget
 
@@ -137,13 +137,14 @@ def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
             error = event.worker.error
             original_error = error.__cause__ if isinstance(error, WorkerFailed) and error.__cause__ else error
 
-            # Every error in worker thread gets converted to InternalServerError so it's handled by the common call to
-            # action in plain2code.py
-            internal_error = InternalServerError(str(original_error))
-            internal_error.__cause__ = original_error
-
-            # Exit the TUI and return the wrapped exception
-            self.exit(result=internal_error)
+            # Connection-related errors are propagated as-is to show helpful error messages
+            # All other errors are wrapped in InternalServerError for consistent handling
+            if isinstance(original_error, NetworkConnectionError):
+                self.exit(result=original_error)
+            else:
+                internal_error = InternalServerError(str(original_error))
+                internal_error.__cause__ = original_error
+                self.exit(result=internal_error)
 
     def _handle_exception(self, error: Exception) -> None:
         """Override Textual's exception handler to suppress console tracebacks for worker errors.