feature: Loop on active workspace until endpoint is ready

When creating a new workspace with wait_on_active=True, the system now waits
for the workspace state to become Active, and then verifies that the endpoint
is actually ready by attempting to establish a connection. This ensures that
the workspace is truly ready for use before returning to the caller.

Added _wait_on_endpoint method in WorkspaceManager that polls the workspace
endpoint with configurable interval and timeout, using a context manager to
properly handle database connections.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: kesmit13

singlestoredb/management/manager.py

@@ -310,3 +310,58 @@ def _wait_on_state(
             out = getattr(self, f'get_{self.obj_type}')(out.id)
 
         return out
+
+    def _wait_on_endpoint(
+        self,
+        out: Any,
+        interval: int = 10,
+        timeout: int = 300,
+    ) -> Any:
+        """
+        Wait for the endpoint to be ready by attempting to connect.
+
+        Parameters
+        ----------
+        out : Any
+            Workspace object with an endpoint attribute
+        interval : int, optional
+            Interval between each connection attempt (default: 10 seconds)
+        timeout : int, optional
+            Maximum time to wait before raising an exception (default: 300 seconds)
+
+        Raises
+        ------
+        ManagementError
+            If timeout is reached or endpoint is not available
+
+        Returns
+        -------
+        Same object type as `out`
+
+        """
+        if not hasattr(out, 'endpoint') or not out.endpoint:
+            raise ManagementError(
+                msg=f'{type(out).__name__} object does not have a valid endpoint',
+            )
+
+        # Import connection module here to avoid circular imports
+        from .. import connection
+
+        while True:
+            try:
+                # Try to establish a connection to the endpoint using context manager
+                with connection.connect(host=out.endpoint, connect_timeout=5):
+                    pass
+                # If connection succeeds, endpoint is ready
+                break
+            except Exception:
+                # If connection fails, check timeout and retry
+                if timeout <= 0:
+                    raise ManagementError(
+                        msg=f'Exceeded waiting time for {self.obj_type} endpoint '
+                            'to become ready',
+                    )
+                time.sleep(interval)
+                timeout -= interval
+
+        return out

singlestoredb/management/workspace.py

@@ -1794,6 +1794,12 @@ def create_workspace(
                 interval=wait_interval,
                 timeout=wait_timeout,
             )
+            # After workspace is active, wait for endpoint to be ready
+            out = self._wait_on_endpoint(
+                out,
+                interval=wait_interval,
+                timeout=wait_timeout,
+            )
         return out
 
     def get_workspace_group(self, id: str) -> WorkspaceGroup: