gmicloud 0.1.0__tar.gz → 0.1.2__tar.gz

gmicloud-0.1.2/PKG-INFO

@@ -0,0 +1,212 @@
+Metadata-Version: 2.2
+Name: gmicloud
+Version: 0.1.2
+Summary: GMI Cloud Python SDK
+Author-email: GMI <gmi@gmitec.net>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# GMICloud SDK
+
+## Overview
+
+The GMI Inference Engine SDK provides a Python interface for deploying and managing machine learning models in
+production environments. It allows users to create model artifacts, schedule tasks for serving models, and call
+inference APIs easily.
+
+This SDK streamlines the process of utilizing GMI Cloud capabilities such as deploying models with Kubernetes-based Ray
+services, managing resources automatically, and accessing model inference endpoints. With minimal setup, developers can
+focus on building ML solutions instead of infrastructure.
+
+## Features
+
+- Artifact Management: Easily create, update, and manage ML model artifacts.
+- Task Management: Quickly create, schedule, and manage deployment tasks for model inference.
+- Usage Data Retrieval : Fetch and analyze usage data to optimize resource allocation.
+
+## Installation
+
+To install the SDK, use pip:
+
+```bash
+pip install gmicloud
+```
+
+## Setup
+
+You must configure authentication credentials for accessing the GMI Cloud API. There are two ways to configure the SDK:
+
+### Option 1: Using Environment Variables
+
+Set the following environment variables:
+
+```shell
+export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
+export GMI_CLOUD_EMAIL=<YOUR_EMAIL>
+export GMI_CLOUD_PASSWORD=<YOUR_PASSWORD>
+```
+
+### Option 2: Passing Credentials as Parameters
+
+Pass `client_id`, `email`, and `password` directly to the Client object when initializing it in your script:
+
+```python
+from gmicloud import Client
+
+client = Client(client_id="<YOUR_CLIENT_ID>", email="<YOUR_EMAIL>", password="<YOUR_PASSWORD>")
+```
+
+## Quick Start
+
+### 1. Create a Task from an Artifact Template
+
+This is the simplest example to deploy an existing artifact template:
+
+```python
+from datetime import datetime
+from gmicloud import Client, TaskScheduling, OneOffScheduling
+from examples.completion import call_chat_completion
+
+# Initialize the client
+client = Client()
+
+# Schedule and start a task from an artifact template
+task = client.create_task_from_artifact_template(
+    "qwen_2.5_14b_instruct_template_001",
+    TaskScheduling(
+        scheduling_oneoff=OneOffScheduling(
+            trigger_timestamp=int(datetime.now().timestamp()) + 10,  # Delay by 10 seconds
+            min_replicas=1,
+            max_replicas=10,
+        )
+    )
+)
+
+# Make a chat completion request via the task endpoint
+response = call_chat_completion(client, task.task_id)
+print(response)
+```
+
+### 2. Step-by-Step Example: Create Artifact, Task, and Query the Endpoint
+
+#### (a) Create an Artifact from a Template
+
+First, you’ll retrieve all templates and create an artifact based on the desired template (e.g., "Llama3.1 8B"):
+
+```python
+def create_artifact_from_template(client):
+    artifact_manager = client.artifact_manager
+
+    # List all available templates
+    templates = artifact_manager.get_artifact_templates()
+    for template in templates:
+        if template.artifact_template_id == "qwen_2.5_14b_instruct_template_001":
+            return artifact_manager.create_artifact_from_template(
+                artifact_template_id=template.artifact_template_id
+            )
+    return None
+```
+
+#### (b) Create a Task from the Artifact
+
+Wait until the artifact becomes "ready" and then deploy it using task scheduling:
+
+```python
+def create_task_and_start(client, artifact_id):
+    artifact_manager = client.artifact_manager
+
+    # Wait until the artifact is ready
+    while True:
+        artifact = artifact_manager.get_artifact(artifact_id)
+        if artifact.build_status == "SUCCESS":
+            break
+        print("Waiting for artifact to be ready...")
+        time.sleep(2)
+
+    # Configure and start the task
+    task_manager = client.task_manager
+    task = task_manager.create_task(Task(
+        config=TaskConfig(
+            ray_task_config=RayTaskConfig(
+                ray_version="2.40.0-py310-gpu",
+                file_path="serve",
+                artifact_id=artifact_id,
+                deployment_name="app",
+                replica_resource=ReplicaResource(
+                    cpu=10,
+                    ram_gb=100,
+                    gpu=1,
+                ),
+            ),
+            task_scheduling=TaskScheduling(
+                scheduling_oneoff=OneOffScheduling(
+                    trigger_timestamp=int(datetime.now().timestamp()) + 10,
+                    min_replicas=1,
+                    max_replicas=10,
+                )
+            ),
+        ),
+    ))
+
+    task_manager.start_task(task.task_id)
+    return task.task_id
+```
+
+### (c) Query the Model Endpoint
+
+Once the task is running, use the endpoint for inference:
+
+```python
+from examples.completion import call_chat_completion
+
+client = Client()
+artifact_id = create_artifact_from_template(client)
+task_id = create_task_and_start(client, artifact_id)
+
+response = call_chat_completion(client, task_id)
+print(response)
+```
+
+## API Reference
+
+### Client
+
+Represents the entry point to interact with GMI Cloud APIs.
+Client(
+client_id: Optional[str] = "",
+email: Optional[str] = "",
+password: Optional[str] = ""
+)
+
+### Artifact Management
+
+* get_artifact_templates(): Fetch a list of available artifact templates.
+* create_artifact_from_template(template_id: str): Create a model artifact from a given template.
+* get_artifact(artifact_id: str): Get details of a specific artifact.
+
+### Task Management
+
+* create_task_from_artifact_template(template_id: str, scheduling: TaskScheduling): Create and schedule a task using an
+  artifact template.
+* start_task(task_id: str): Start a task.
+* get_task(task_id: str): Retrieve the status and details of a specific task.
+
+## Notes & Troubleshooting
+
+Ensure Credentials are Correct: Double-check your environment variables or parameters passed into the Client object.
+Artifact Status: It may take a few minutes for an artifact or task to transition to the "running" state.
+Inference Endpoint Readiness: Use the task endpoint only after the task status changes to "running".
+Default OpenAI Key: By default, the OpenAI API base URL is derived from the endpoint provided by GMI.
+
+## Contributing
+
+We welcome contributions to enhance the SDK. Please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bugfix.
+3. Commit changes with clear messages.
+4. Submit a pull request for review.

gmicloud-0.1.2/README.md

@@ -0,0 +1,200 @@
+# GMICloud SDK
+
+## Overview
+
+The GMI Inference Engine SDK provides a Python interface for deploying and managing machine learning models in
+production environments. It allows users to create model artifacts, schedule tasks for serving models, and call
+inference APIs easily.
+
+This SDK streamlines the process of utilizing GMI Cloud capabilities such as deploying models with Kubernetes-based Ray
+services, managing resources automatically, and accessing model inference endpoints. With minimal setup, developers can
+focus on building ML solutions instead of infrastructure.
+
+## Features
+
+- Artifact Management: Easily create, update, and manage ML model artifacts.
+- Task Management: Quickly create, schedule, and manage deployment tasks for model inference.
+- Usage Data Retrieval : Fetch and analyze usage data to optimize resource allocation.
+
+## Installation
+
+To install the SDK, use pip:
+
+```bash
+pip install gmicloud
+```
+
+## Setup
+
+You must configure authentication credentials for accessing the GMI Cloud API. There are two ways to configure the SDK:
+
+### Option 1: Using Environment Variables
+
+Set the following environment variables:
+
+```shell
+export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
+export GMI_CLOUD_EMAIL=<YOUR_EMAIL>
+export GMI_CLOUD_PASSWORD=<YOUR_PASSWORD>
+```
+
+### Option 2: Passing Credentials as Parameters
+
+Pass `client_id`, `email`, and `password` directly to the Client object when initializing it in your script:
+
+```python
+from gmicloud import Client
+
+client = Client(client_id="<YOUR_CLIENT_ID>", email="<YOUR_EMAIL>", password="<YOUR_PASSWORD>")
+```
+
+## Quick Start
+
+### 1. Create a Task from an Artifact Template
+
+This is the simplest example to deploy an existing artifact template:
+
+```python
+from datetime import datetime
+from gmicloud import Client, TaskScheduling, OneOffScheduling
+from examples.completion import call_chat_completion
+
+# Initialize the client
+client = Client()
+
+# Schedule and start a task from an artifact template
+task = client.create_task_from_artifact_template(
+    "qwen_2.5_14b_instruct_template_001",
+    TaskScheduling(
+        scheduling_oneoff=OneOffScheduling(
+            trigger_timestamp=int(datetime.now().timestamp()) + 10,  # Delay by 10 seconds
+            min_replicas=1,
+            max_replicas=10,
+        )
+    )
+)
+
+# Make a chat completion request via the task endpoint
+response = call_chat_completion(client, task.task_id)
+print(response)
+```
+
+### 2. Step-by-Step Example: Create Artifact, Task, and Query the Endpoint
+
+#### (a) Create an Artifact from a Template
+
+First, you’ll retrieve all templates and create an artifact based on the desired template (e.g., "Llama3.1 8B"):
+
+```python
+def create_artifact_from_template(client):
+    artifact_manager = client.artifact_manager
+
+    # List all available templates
+    templates = artifact_manager.get_artifact_templates()
+    for template in templates:
+        if template.artifact_template_id == "qwen_2.5_14b_instruct_template_001":
+            return artifact_manager.create_artifact_from_template(
+                artifact_template_id=template.artifact_template_id
+            )
+    return None
+```
+
+#### (b) Create a Task from the Artifact
+
+Wait until the artifact becomes "ready" and then deploy it using task scheduling:
+
+```python
+def create_task_and_start(client, artifact_id):
+    artifact_manager = client.artifact_manager
+
+    # Wait until the artifact is ready
+    while True:
+        artifact = artifact_manager.get_artifact(artifact_id)
+        if artifact.build_status == "SUCCESS":
+            break
+        print("Waiting for artifact to be ready...")
+        time.sleep(2)
+
+    # Configure and start the task
+    task_manager = client.task_manager
+    task = task_manager.create_task(Task(
+        config=TaskConfig(
+            ray_task_config=RayTaskConfig(
+                ray_version="2.40.0-py310-gpu",
+                file_path="serve",
+                artifact_id=artifact_id,
+                deployment_name="app",
+                replica_resource=ReplicaResource(
+                    cpu=10,
+                    ram_gb=100,
+                    gpu=1,
+                ),
+            ),
+            task_scheduling=TaskScheduling(
+                scheduling_oneoff=OneOffScheduling(
+                    trigger_timestamp=int(datetime.now().timestamp()) + 10,
+                    min_replicas=1,
+                    max_replicas=10,
+                )
+            ),
+        ),
+    ))
+
+    task_manager.start_task(task.task_id)
+    return task.task_id
+```
+
+### (c) Query the Model Endpoint
+
+Once the task is running, use the endpoint for inference:
+
+```python
+from examples.completion import call_chat_completion
+
+client = Client()
+artifact_id = create_artifact_from_template(client)
+task_id = create_task_and_start(client, artifact_id)
+
+response = call_chat_completion(client, task_id)
+print(response)
+```
+
+## API Reference
+
+### Client
+
+Represents the entry point to interact with GMI Cloud APIs.
+Client(
+client_id: Optional[str] = "",
+email: Optional[str] = "",
+password: Optional[str] = ""
+)
+
+### Artifact Management
+
+* get_artifact_templates(): Fetch a list of available artifact templates.
+* create_artifact_from_template(template_id: str): Create a model artifact from a given template.
+* get_artifact(artifact_id: str): Get details of a specific artifact.
+
+### Task Management
+
+* create_task_from_artifact_template(template_id: str, scheduling: TaskScheduling): Create and schedule a task using an
+  artifact template.
+* start_task(task_id: str): Start a task.
+* get_task(task_id: str): Retrieve the status and details of a specific task.
+
+## Notes & Troubleshooting
+
+Ensure Credentials are Correct: Double-check your environment variables or parameters passed into the Client object.
+Artifact Status: It may take a few minutes for an artifact or task to transition to the "running" state.
+Inference Endpoint Readiness: Use the task endpoint only after the task status changes to "running".
+Default OpenAI Key: By default, the OpenAI API base URL is derived from the endpoint provided by GMI.
+
+## Contributing
+
+We welcome contributions to enhance the SDK. Please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bugfix.
+3. Commit changes with clear messages.
+4. Submit a pull request for review.

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/__init__.py

@@ -5,14 +5,14 @@ from ._internal._models import (
     Task,
     TaskOwner,
     TaskConfig,
-    TaskInfo,
+    EndpointInfo,
     RayTaskConfig,
     TaskScheduling,
     ReplicaResource,
     OneOffScheduling,
     DailyScheduling,
     DailyTrigger,
-    ArtifactTemplate
+    ArtifactTemplate,
 )
 from ._internal._enums import (
     BuildStatus,
@@ -28,7 +28,7 @@ __all__ = [
     "Task",
     "TaskOwner",
     "TaskConfig",
-    "TaskInfo",
+    "EndpointInfo",
     "RayTaskConfig",
     "TaskScheduling",
     "ReplicaResource",
@@ -37,5 +37,5 @@ __all__ = [
     "DailyTrigger",
     "ArtifactTemplate",
     "BuildStatus",
-    "TaskEndpointStatus"
+    "TaskEndpointStatus",
 ]

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/_internal/_client/_artifact_client.py

@@ -42,11 +42,10 @@ class ArtifactClient:
         return Artifact.model_validate(result)
 
     @handle_refresh_token
-    def get_all_artifacts(self, user_id: str) -> List[Artifact]:
+    def get_all_artifacts(self) -> List[Artifact]:
         """
-        Fetches all artifacts for a given user ID.
+        Fetches all artifacts.
 
-        :param user_id: The ID of the user whose artifacts are being fetched.
         :return: A list of Artifact objects.
         :rtype: List[Artifact]
         """
@@ -54,7 +53,7 @@ class ArtifactClient:
             ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
             CLIENT_ID_HEADER: self.iam_client.get_client_id()
         }
-        result = self.client.get("/get_all_artifacts", custom_headers, {"user_id": user_id})
+        result = self.client.get("/get_all_artifacts", custom_headers)
         if not result:
             return []
         return [Artifact.model_validate(item) for item in result]
@@ -77,12 +76,11 @@ class ArtifactClient:
         return CreateArtifactResponse.model_validate(result)
 
     @handle_refresh_token
-    def create_artifact_from_template(self,
-                                      request: CreateArtifactFromTemplateRequest) -> CreateArtifactFromTemplateResponse:
+    def create_artifact_from_template(self, artifact_template_id: str) -> CreateArtifactFromTemplateResponse:
         """
         Creates a new artifact in the service.
 
-        :param request: The request object containing artifact details.
+        :param artifact_template_id: The ID of the artifact template to use.
         :return: The response object containing the created artifact details.
         :rtype: CreateArtifactFromTemplateResponse
         """
@@ -91,7 +89,7 @@ class ArtifactClient:
             CLIENT_ID_HEADER: self.iam_client.get_client_id()
         }
         result = self.client.post("/create_artifact_from_template", custom_headers,
-                                  request.model_dump())
+                                  {"artifact_template_id": artifact_template_id})
 
         return CreateArtifactFromTemplateResponse.model_validate(result)
 

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/_internal/_client/_http_client.py

@@ -39,7 +39,6 @@ class HTTPClient:
         :return: The JSON response parsed as a Python dictionary.
         :raises APIError: If the request fails or the response is invalid.
         """
-        print("data=", data)
         url = self._prepare_url(endpoint)
         headers = {
             ACCEPT_HEADER: JSON_CONTENT_TYPE,
@@ -52,21 +51,7 @@ class HTTPClient:
 
         response = None
         try:
-            # if method == HTTP_METHOD_POST:
-            #     response = requests.post(url, json=data, headers=headers)
-            # elif method == HTTP_METHOD_GET:
-            #     response = requests.get(url, params=params, headers=headers)
-            # elif method == HTTP_METHOD_PATCH:
-            #     response = requests.patch(url, data=data, headers=headers)
-            # elif method == HTTP_METHOD_DELETE:
-            #     response = requests.delete(url, params=params, headers=headers)
-            # else:
-            #     raise APIError(f"Unsupported HTTP method: {method}")
             response = requests.request(method, url, params=params, json=data, headers=headers)
-            # response = method_map[method](url, json=data if method != HTTP_METHOD_GET else None,
-            #                               params=params, headers=headers)
-
-            print("=============", response.text)
             if response.status_code == 401:
                 raise UnauthorizedError("Access token expired or invalid.")
             elif response.status_code != 200 and response.status_code != 201:
@@ -75,7 +60,6 @@ class HTTPClient:
                 else:
                     error_message = response.json().get('message', 'Unknown error')
                 raise APIError(f"HTTP Request failed: {error_message}")
-
             # Raise for HTTP errors
             response.raise_for_status()
 

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/_internal/_client/_task_client.py

@@ -39,7 +39,7 @@ class TaskClient:
         return Task.model_validate(result)
 
     @handle_refresh_token
-    def get_all_tasks(self, user_id: str) -> GetAllTasksResponse:
+    def get_all_tasks(self) -> GetAllTasksResponse:
         """
         Retrieves all tasks from the task service.
 
@@ -50,7 +50,7 @@ class TaskClient:
             ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
             CLIENT_ID_HEADER: self.iam_client.get_client_id()
         }
-        result = self.client.get("/get_tasks", custom_headers, {"user_id": user_id})
+        result = self.client.get("/get_tasks", custom_headers)
         if not result:
             return GetAllTasksResponse(tasks=[])
 

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/_internal/_enums.py

@@ -14,6 +14,7 @@ class BuildStatus(str, Enum):
 
 
 class TaskEndpointStatus(str, Enum):
+    UNKNOWN = ""
     PENDING = "pending"
     DEPLOYING = "deploying"
     SCALING = "scaling"
@@ -21,3 +22,4 @@ class TaskEndpointStatus(str, Enum):
     ARCHIVED = "archived"
     READY = "ready"
     UNREADY = "unready"
+    NEW = "new"

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/_internal/_manager/_artifact_manager.py

@@ -43,7 +43,7 @@ class ArtifactManager:
         :return: A list of Artifact objects associated with the user.
         :rtype: List[Artifact]
         """
-        return self.artifact_client.get_all_artifacts(self.iam_client.get_user_id())
+        return self.artifact_client.get_all_artifacts()
 
     def create_artifact(
             self,
@@ -63,27 +63,25 @@ class ArtifactManager:
         if not artifact_name or not artifact_name.strip():
             raise ValueError("Artifact name is required and cannot be empty.")
 
-        req = CreateArtifactRequest(user_id=self.iam_client.get_user_id(), artifact_name=artifact_name,
+        req = CreateArtifactRequest(artifact_name=artifact_name,
                                     artifact_description=description,
                                     artifact_tags=tags, )
 
         return self.artifact_client.create_artifact(req)
 
-    def create_artifact_from_template(self, artifact_template_id: str) -> CreateArtifactFromTemplateResponse:
+    def create_artifact_from_template(self, artifact_template_id: str) -> str:
         """
         Create a new artifact for a user using a template.
 
         :param artifact_template_id: The ID of the template to use for the artifact.
-        :return: A `CreateArtifactResponse` object containing information about the created artifact.
-        :rtype: CreateArtifactResponse
+        :return: The `artifact_id` of the created artifact.
+        :rtype: str
+        :raises ValueError: If `artifact_template_id` is None or empty.
         """
         if not artifact_template_id or not artifact_template_id.strip():
             raise ValueError("Artifact template ID is required and cannot be empty.")
 
-        req = CreateArtifactFromTemplateRequest(user_id=self.iam_client.get_user_id(),
-                                                artifact_template_id=artifact_template_id)
-
-        return self.artifact_client.create_artifact_from_template(req)
+        return self.artifact_client.create_artifact_from_template(artifact_template_id).artifact_id
 
     def rebuild_artifact(self, artifact_id: str) -> RebuildArtifactResponse:
         """

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/_internal/_manager/_task_manager.py

@@ -106,7 +106,6 @@ class TaskManager:
         self._validate_file_path(config_file_path)
 
         task = self._read_file_and_parse_task(config_file_path)
-        print("================", task)
         task.task_id = task_id
         task.config.ray_task_config.artifact_id = artifact_id
 
@@ -213,7 +212,6 @@ class TaskManager:
             file_data = file.read()
 
         try:
-            print("!!!!!!!!!!!1", file_data)
             task = Task.model_validate_json(file_data)  # Ensure Task has a static method for model validation.
         except Exception as e:
             raise ValueError(f"Failed to parse Task from file: {file_path}. Error: {str(e)}")

{gmicloud-0.1.0 → gmicloud-0.1.2}/gmicloud/_internal/_models.py

@@ -66,7 +66,6 @@ class CreateArtifactRequest(BaseModel):
     """
     Request object to create a new artifact.
     """
-    user_id: str  # The user ID creating the artifact.
     artifact_name: str  # The name of the artifact to create.
     artifact_description: Optional[str] = ""  # Description of the artifact.
     artifact_tags: Optional[List[str]] = None  # Tags for the artifact, separated by commas.
@@ -146,6 +145,20 @@ class ArtifactTemplate(BaseModel):
     artifact_description: Optional[str] = ""  # Description of the artifact template.
     artifact_name: Optional[str] = ""  # Name of the artifact template.
     artifact_tags: Optional[List[str]] = None  # Tags associated with the artifact template.
+    ray: Optional["RayTemplate"] = None  # Template for Ray-based artifacts.
+    resources: Optional["ResourcesTemplate"] = None  # Resource allocation template.
+
+
+class RayTemplate(BaseModel):
+    deployment_name: Optional[str] = ""  # Name of the deployment.
+    file_path: Optional[str] = ""  # Path to the task file in storage.
+    version: Optional[str] = ""  # Version of Ray used.
+
+
+class ResourcesTemplate(BaseModel):
+    cpu: Optional[int] = 0  # Number of CPU cores allocated.
+    memory: Optional[int] = 0  # Amount of RAM (in GB) allocated.
+    gpu: Optional[int] = 0  # Number of GPUs allocated.
 
 
 class CreateArtifactFromTemplateRequest(BaseModel):
@@ -203,7 +216,7 @@ class RayTaskConfig(BaseModel):
     file_path: Optional[str] = ""  # Path to the task file in storage.
     deployment_name: Optional[str] = ""  # Name of the deployment.
     replica_resource: Optional[ReplicaResource] = None  # Resources allocated for task replicas.
-    volume_mounts: Optional[VolumeMount] = None  # Configuration for mounted volumes.
+    volume_mounts: Optional[List[VolumeMount]] = None  # Configuration for mounted volumes.
 
 
 class OneOffScheduling(BaseModel):
@@ -252,12 +265,12 @@ class TaskConfig(BaseModel):
     last_update_timestamp: Optional[int] = 0  # Timestamp when the task was last updated.
 
 
-class TaskInfo(BaseModel):
+class EndpointInfo(BaseModel):
     """
-    Additional information about a task.
+    Additional information about the task endpoint.
     """
     endpoint_status: Optional[TaskEndpointStatus] = None  # Current status of the task (e.g., running, stopped).
-    endpoint: Optional[str] = ""  # API endpoint exposed by the task, if applicable.
+    endpoint_url: Optional[str] = ""  # URL for accessing the task endpoint.
 
 
 class UserPreference(BaseModel):
@@ -275,7 +288,8 @@ class Task(BaseModel):
     task_id: Optional[str] = None  # Unique identifier for the task.
     owner: Optional[TaskOwner] = None  # Ownership information of the task.
     config: Optional[TaskConfig] = None  # Configuration data for the task.
-    info: Optional[TaskInfo] = None  # Additional information about the task.
+    endpoint_info: Optional[EndpointInfo] = None  # Additional information about the task endpoint.
+    cluster_endpoints: Optional[List[EndpointInfo]] = None  # Endpoints for the task cluster.
     task_status: Optional[str] = ""  # Status of the task.
     readiness_status: Optional[str] = ""  # Readiness status of the task.
     user_preference: Optional[UserPreference] = None  # User preference for the task.