oracle-ads 2.13.12__py3-none-any.whl → 2.13.13__py3-none-any.whl

ads/aqua/app.py

@@ -5,6 +5,7 @@
 import json
 import os
 import traceback
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import fields
 from datetime import datetime, timedelta
 from itertools import chain
@@ -58,6 +59,8 @@ from ads.telemetry.client import TelemetryClient
 class AquaApp:
     """Base Aqua App to contain common components."""
 
+    MAX_WORKERS = 10  # Number of workers for asynchronous resource loading
+
     @telemetry(name="aqua")
     def __init__(self) -> None:
         if OCI_RESOURCE_PRINCIPAL_VERSION:
@@ -128,20 +131,69 @@ class AquaApp:
             update_model_provenance_details=update_model_provenance_details,
         )
 
-    # TODO: refactor model evaluation implementation to use it.
     @staticmethod
     def get_source(source_id: str) -> Union[ModelDeployment, DataScienceModel]:
-        if is_valid_ocid(source_id):
-            if "datasciencemodeldeployment" in source_id:
-                return ModelDeployment.from_id(source_id)
-            elif "datasciencemodel" in source_id:
-                return DataScienceModel.from_id(source_id)
+        """
+        Fetches a model or model deployment based on the provided OCID.
+
+        Parameters
+        ----------
+        source_id : str
+            OCID of the Data Science model or model deployment.
+
+        Returns
+        -------
+        Union[ModelDeployment, DataScienceModel]
+            The corresponding resource object.
+
+        Raises
+        ------
+        AquaValueError
+            If the OCID is invalid or unsupported.
+        """
+        logger.debug(f"Resolving source for ID: {source_id}")
+        if not is_valid_ocid(source_id):
+            logger.error(f"Invalid OCID format: {source_id}")
+            raise AquaValueError(
+                f"Invalid source ID: {source_id}. Please provide a valid model or model deployment OCID."
+            )
+
+        if "datasciencemodeldeployment" in source_id:
+            logger.debug(f"Identified as ModelDeployment OCID: {source_id}")
+            return ModelDeployment.from_id(source_id)
 
+        if "datasciencemodel" in source_id:
+            logger.debug(f"Identified as DataScienceModel OCID: {source_id}")
+            return DataScienceModel.from_id(source_id)
+
+        logger.error(f"Unrecognized OCID type: {source_id}")
         raise AquaValueError(
-            f"Invalid source {source_id}. "
-            "Specify either a model or model deployment id."
+            f"Unsupported source ID type: {source_id}. Must be a model or model deployment OCID."
         )
 
+    def get_multi_source(
+        self,
+        ids: List[str],
+    ) -> Dict[str, Union[ModelDeployment, DataScienceModel]]:
+        """
+        Retrieves multiple DataScience resources concurrently.
+
+        Parameters
+        ----------
+        ids : List[str]
+            A list of DataScience OCIDs.
+
+        Returns
+        -------
+        Dict[str, Union[ModelDeployment, DataScienceModel]]
+            A mapping from OCID to the corresponding resolved resource object.
+        """
+        logger.debug(f"Fetching {ids} sources in parallel.")
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            results = list(executor.map(self.get_source, ids))
+
+        return dict(zip(ids, results))
+
     # TODO: refactor model evaluation implementation to use it.
     @staticmethod
     def create_model_version_set(

ads/aqua/cli.py

@@ -14,6 +14,7 @@ from ads.aqua.evaluation import AquaEvaluationApp
 from ads.aqua.finetuning import AquaFineTuningApp
 from ads.aqua.model import AquaModelApp
 from ads.aqua.modeldeployment import AquaDeploymentApp
+from ads.aqua.verify_policies import AquaVerifyPoliciesApp
 from ads.common.utils import LOG_LEVELS
 
 
@@ -29,6 +30,7 @@ class AquaCommand:
     fine_tuning = AquaFineTuningApp
     deployment = AquaDeploymentApp
     evaluation = AquaEvaluationApp
+    verify_policies = AquaVerifyPoliciesApp
 
     def __init__(
         self,

ads/aqua/client/client.py

@@ -61,13 +61,20 @@ class HttpxOCIAuth(httpx.Auth):
 
     def __init__(self, signer: Optional[oci.signer.Signer] = None):
         """
-        Initialize the HttpxOCIAuth instance.
+        Initializes the authentication handler with the given or default OCI signer.
 
-        Args:
-            signer (oci.signer.Signer): The OCI signer to use for signing requests.
+        Parameters
+        ----------
+        signer : oci.signer.Signer, optional
+            The OCI signer instance to use. If None, a default signer will be retrieved.
         """
-
-        self.signer = signer or authutil.default_signer().get("signer")
+        try:
+            self.signer = signer or authutil.default_signer().get("signer")
+            if not self.signer:
+                raise ValueError("OCI signer could not be initialized.")
+        except Exception as e:
+            logger.error("Failed to initialize OCI signer: %s", e)
+            raise
 
     def auth_flow(self, request: httpx.Request) -> Iterator[httpx.Request]:
         """
@@ -80,21 +87,31 @@ class HttpxOCIAuth(httpx.Auth):
             httpx.Request: The signed HTTPX request.
         """
         # Create a requests.Request object from the HTTPX request
-        req = requests.Request(
-            method=request.method,
-            url=str(request.url),
-            headers=dict(request.headers),
-            data=request.content,
-        )
-        prepared_request = req.prepare()
+        try:
+            req = requests.Request(
+                method=request.method,
+                url=str(request.url),
+                headers=dict(request.headers),
+                data=request.content,
+            )
+            prepared_request = req.prepare()
+            self.signer.do_request_sign(prepared_request)
+
+            # Replace headers on the original HTTPX request with signed headers
+            request.headers.update(prepared_request.headers)
+            logger.debug("Successfully signed request to %s", request.url)
 
-        # Sign the request using the OCI Signer
-        self.signer.do_request_sign(prepared_request)
+            # Fix for GET/DELETE requests that OCI Gateway expects with Content-Length
+            if (
+                request.method in ["GET", "DELETE"]
+                and "content-length" not in request.headers
+            ):
+                request.headers["content-length"] = "0"
 
-        # Update the original HTTPX request with the signed headers
-        request.headers.update(prepared_request.headers)
+        except Exception as e:
+            logger.error("Failed to sign request to %s: %s", request.url, e)
+            raise
 
-        # Proceed with the request
         yield request
 
 
@@ -330,8 +347,8 @@ class BaseClient:
             "Content-Type": "application/json",
             "Accept": "text/event-stream" if stream else "application/json",
         }
-        if stream:
-            default_headers["enable-streaming"] = "true"
+        # if stream:
+        #     default_headers["enable-streaming"] = "true"
         if headers:
             default_headers.update(headers)
 
@@ -495,7 +512,7 @@ class Client(BaseClient):
         prompt: str,
         payload: Optional[Dict[str, Any]] = None,
         headers: Optional[Dict[str, str]] = None,
-        stream: bool = True,
+        stream: bool = False,
     ) -> Union[Dict[str, Any], Iterator[Mapping[str, Any]]]:
         """
         Generate text completion for the given prompt.
@@ -521,7 +538,7 @@ class Client(BaseClient):
         messages: List[Dict[str, Any]],
         payload: Optional[Dict[str, Any]] = None,
         headers: Optional[Dict[str, str]] = None,
-        stream: bool = True,
+        stream: bool = False,
     ) -> Union[Dict[str, Any], Iterator[Mapping[str, Any]]]:
         """
         Perform a chat interaction with the model.

ads/aqua/client/openai_client.py

@@ -32,7 +32,7 @@ class ModelDeploymentBaseEndpoint(ExtendedEnum):
     """Supported base endpoints for model deployments."""
 
     PREDICT = "predict"
-    PREDICT_WITH_RESPONSE_STREAM = "predictwithresponsestream"
+    PREDICT_WITH_RESPONSE_STREAM = "predictWithResponseStream"
 
 
 class AquaOpenAIMixin:
@@ -51,9 +51,9 @@ class AquaOpenAIMixin:
         Returns:
             str: The normalized OpenAI-compatible route path (e.g., '/v1/chat/completions').
         """
-        normalized_path = original_path.lower().rstrip("/")
+        normalized_path = original_path.rstrip("/")
 
-        match = re.search(r"/predict(withresponsestream)?", normalized_path)
+        match = re.search(r"/predict(WithResponseStream)?", normalized_path)
         if not match:
             logger.debug("Route header cannot be resolved from path: %s", original_path)
             return ""
@@ -71,7 +71,7 @@ class AquaOpenAIMixin:
                 "Route suffix does not start with a version prefix (e.g., '/v1'). "
                 "This may lead to compatibility issues with OpenAI-style endpoints. "
                 "Consider updating the URL to include a version prefix, "
-                "such as '/predict/v1' or '/predictwithresponsestream/v1'."
+                "such as '/predict/v1' or '/predictWithResponseStream/v1'."
             )
             # route_suffix = f"v1/{route_suffix}"
 
@@ -124,13 +124,13 @@ class AquaOpenAIMixin:
 
     def _patch_url(self) -> httpx.URL:
         """
-        Strips any suffixes from the base URL to retain only the `/predict` or `/predictwithresponsestream` path.
+        Strips any suffixes from the base URL to retain only the `/predict` or `/predictWithResponseStream` path.
 
         Returns:
             httpx.URL: The normalized base URL with the correct model deployment path.
         """
-        base_path = f"{self.base_url.path.lower().rstrip('/')}/"
-        match = re.search(r"/predict(withresponsestream)?/", base_path)
+        base_path = f"{self.base_url.path.rstrip('/')}/"
+        match = re.search(r"/predict(WithResponseStream)?/", base_path)
         if match:
             trimmed = base_path[: match.end() - 1]
             return self.base_url.copy_with(path=trimmed)
@@ -144,7 +144,7 @@ class AquaOpenAIMixin:
 
         This includes:
         - Patching headers with streaming and routing info.
-        - Normalizing the URL path to include only `/predict` or `/predictwithresponsestream`.
+        - Normalizing the URL path to include only `/predict` or `/predictWithResponseStream`.
 
         Args:
             request (httpx.Request): The outgoing HTTPX request.
@@ -176,6 +176,7 @@ class OpenAI(openai.OpenAI, AquaOpenAIMixin):
         http_client: Optional[httpx.Client] = None,
         http_client_kwargs: Optional[Dict[str, Any]] = None,
         _strict_response_validation: bool = False,
+        patch_headers: bool = False,
         **kwargs: Any,
     ) -> None:
         """
@@ -196,6 +197,7 @@ class OpenAI(openai.OpenAI, AquaOpenAIMixin):
             http_client (httpx.Client, optional): Custom HTTP client; if not provided, one will be auto-created.
             http_client_kwargs (dict[str, Any], optional): Extra kwargs for auto-creating the HTTP client.
             _strict_response_validation (bool, optional): Enable strict response validation.
+            patch_headers (bool, optional): If True, redirects the requests by modifying the headers.
             **kwargs: Additional keyword arguments passed to the parent __init__.
         """
         if http_client is None:
@@ -207,6 +209,8 @@ class OpenAI(openai.OpenAI, AquaOpenAIMixin):
             logger.debug("API key not provided; using default placeholder for OCI.")
             api_key = "OCI"
 
+        self.patch_headers = patch_headers
+
         super().__init__(
             api_key=api_key,
             organization=organization,
@@ -229,7 +233,8 @@ class OpenAI(openai.OpenAI, AquaOpenAIMixin):
         Args:
             request (httpx.Request): The outgoing HTTP request.
         """
-        self._prepare_request_common(request)
+        if self.patch_headers:
+            self._prepare_request_common(request)
 
 
 class AsyncOpenAI(openai.AsyncOpenAI, AquaOpenAIMixin):
@@ -248,6 +253,7 @@ class AsyncOpenAI(openai.AsyncOpenAI, AquaOpenAIMixin):
         http_client: Optional[httpx.Client] = None,
         http_client_kwargs: Optional[Dict[str, Any]] = None,
         _strict_response_validation: bool = False,
+        patch_headers: bool = False,
         **kwargs: Any,
     ) -> None:
         """
@@ -269,6 +275,7 @@ class AsyncOpenAI(openai.AsyncOpenAI, AquaOpenAIMixin):
             http_client (httpx.AsyncClient, optional): Custom asynchronous HTTP client; if not provided, one will be auto-created.
             http_client_kwargs (dict[str, Any], optional): Extra kwargs for auto-creating the HTTP client.
             _strict_response_validation (bool, optional): Enable strict response validation.
+            patch_headers (bool, optional): If True, redirects the requests by modifying the headers.
             **kwargs: Additional keyword arguments passed to the parent __init__.
         """
         if http_client is None:
@@ -280,6 +287,8 @@ class AsyncOpenAI(openai.AsyncOpenAI, AquaOpenAIMixin):
             logger.debug("API key not provided; using default placeholder for OCI.")
             api_key = "OCI"
 
+        self.patch_headers = patch_headers
+
         super().__init__(
             api_key=api_key,
             organization=organization,
@@ -302,4 +311,5 @@ class AsyncOpenAI(openai.AsyncOpenAI, AquaOpenAIMixin):
         Args:
             request (httpx.Request): The outgoing HTTP request.
         """
-        self._prepare_request_common(request)
+        if self.patch_headers:
+            self._prepare_request_common(request)

ads/aqua/common/entities.py

@@ -6,7 +6,7 @@ import re
 from typing import Any, Dict, List, Optional
 
 from oci.data_science.models import Model
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from ads.aqua import logger
 from ads.aqua.config.utils.serializer import Serializable
@@ -80,24 +80,29 @@ class GPUShapesIndex(Serializable):
 
 class ComputeShapeSummary(Serializable):
     """
-    Represents the specifications of a compute instance's shape.
+    Represents the specifications of a compute instance shape,
+    including CPU, memory, and optional GPU characteristics.
     """
 
     core_count: Optional[int] = Field(
-        default=None, description="The number of CPU cores available."
+        default=None,
+        description="Total number of CPU cores available for the compute shape.",
     )
     memory_in_gbs: Optional[int] = Field(
-        default=None, description="The amount of memory (in GB) available."
+        default=None,
+        description="Amount of memory (in GB) available for the compute shape.",
     )
     name: Optional[str] = Field(
-        default=None, description="The name identifier of the compute shape."
+        default=None,
+        description="Full name of the compute shape, e.g., 'VM.GPU.A10.2'.",
     )
     shape_series: Optional[str] = Field(
-        default=None, description="The series or category of the compute shape."
+        default=None,
+        description="Shape family or series, e.g., 'GPU', 'Standard', etc.",
     )
     gpu_specs: Optional[GPUSpecs] = Field(
         default=None,
-        description="The GPU specifications associated with the compute shape.",
+        description="Optional GPU specifications associated with the shape.",
     )
 
     @model_validator(mode="after")
@@ -136,27 +141,46 @@ class ComputeShapeSummary(Serializable):
         return model
 
 
-class LoraModuleSpec(Serializable):
+class LoraModuleSpec(BaseModel):
     """
-    Lightweight descriptor for LoRA Modules used in fine-tuning models.
+    Descriptor for a LoRA (Low-Rank Adaptation) module used in fine-tuning base models.
+
+    This class is used to define a single fine-tuned module that can be loaded during
+    multi-model deployment alongside a base model.
 
     Attributes
     ----------
     model_id : str
-        The unique identifier of the fine tuned model.
-    model_name : str
-        The name of the fine-tuned model.
-    model_path : str
-        The model-by-reference path to the LoRA Module within the model artifact
+        The OCID of the fine-tuned model registered in the OCI Model Catalog.
+    model_name : Optional[str]
+        The unique name used to route inference requests to this model variant.
+    model_path : Optional[str]
+        The relative path within the artifact pointing to the LoRA adapter weights.
     """
 
-    model_id: Optional[str] = Field(None, description="The fine tuned model OCID to deploy.")
-    model_name: Optional[str] = Field(None, description="The name of the fine-tuned model.")
+    model_config = ConfigDict(protected_namespaces=(), extra="allow")
+
+    model_id: str = Field(
+        ...,
+        description="OCID of the fine-tuned model (must be registered in the Model Catalog).",
+    )
+    model_name: Optional[str] = Field(
+        default=None,
+        description="Name assigned to the fine-tuned model for serving (used as inference route).",
+    )
     model_path: Optional[str] = Field(
-        None,
-        description="The model-by-reference path to the LoRA Module within the model artifact.",
+        default=None,
+        description="Relative path to the LoRA weights inside the model artifact.",
     )
 
+    @model_validator(mode="before")
+    @classmethod
+    def validate_lora_module(cls, data: dict) -> dict:
+        """Validates that required structure exists for a LoRA module."""
+        if "model_id" not in data or not data["model_id"]:
+            raise ValueError("Missing required field: 'model_id' for fine-tuned model.")
+        return data
+
 
 class AquaMultiModelRef(Serializable):
     """
@@ -203,6 +227,22 @@ class AquaMultiModelRef(Serializable):
         description="For fine tuned models, the artifact path of the modified model weights",
     )
 
+    def all_model_ids(self) -> List[str]:
+        """
+        Returns all associated model OCIDs, including the base model and any fine-tuned models.
+
+        Returns
+        -------
+        List[str]
+            A list of all model OCIDs associated with this multi-model reference.
+        """
+        ids = {self.model_id}
+        if self.fine_tune_weights:
+            ids.update(
+                module.model_id for module in self.fine_tune_weights if module.model_id
+            )
+        return list(ids)
+
     class Config:
         extra = "ignore"
         protected_namespaces = ()

ads/aqua/constants.py

@@ -55,6 +55,8 @@ SERVICE_MANAGED_CONTAINER_URI_SCHEME = "dsmc://"
 SUPPORTED_FILE_FORMATS = ["jsonl"]
 MODEL_BY_REFERENCE_OSS_PATH_KEY = "artifact_location"
 
+AQUA_CHAT_TEMPLATE_METADATA_KEY = "chat_template"
+
 CONSOLE_LINK_RESOURCE_TYPE_MAPPING = {
     "datasciencemodel": "models",
     "datasciencemodeldeployment": "model-deployments",

ads/aqua/extension/common_handler.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 # Copyright (c) 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
-
-
+import json
+import os
 from importlib import metadata
 
 import huggingface_hub
@@ -18,6 +18,10 @@ from ads.aqua.common.utils import (
 )
 from ads.aqua.extension.base_handler import AquaAPIhandler
 from ads.aqua.extension.errors import Errors
+from ads.common.object_storage_details import ObjectStorageDetails
+from ads.common.utils import read_file
+from ads.config import CONDA_BUCKET_NAME, CONDA_BUCKET_NS
+from ads.opctl.operator.common.utils import default_signer
 
 
 class ADSVersionHandler(AquaAPIhandler):
@@ -28,6 +32,46 @@ class ADSVersionHandler(AquaAPIhandler):
         self.finish({"data": metadata.version("oracle_ads")})
 
 
+class AquaVersionHandler(AquaAPIhandler):
+    @handle_exceptions
+    def get(self):
+        """
+        Returns the current and latest deployed version of AQUA
+
+        {
+          "installed": {
+            "aqua": "0.1.3.0",
+            "ads": "2.14.2"
+          },
+          "latest": {
+            "aqua": "0.1.4.0",
+            "ads": "2.14.4"
+          }
+        }
+
+        """
+
+        current_aqua_version_path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "..", "version.json"
+        )
+        current_aqua_version = json.loads(read_file(current_aqua_version_path))
+        current_ads_version = {"ads": metadata.version("oracle_ads")}
+        current_version = {"installed": {**current_aqua_version, **current_ads_version}}
+        try:
+            latest_version_artifact_path = ObjectStorageDetails(
+                CONDA_BUCKET_NAME,
+                CONDA_BUCKET_NS,
+                "service_pack/aqua_latest_version.json",
+            ).path
+            latest_version = json.loads(
+                read_file(latest_version_artifact_path, auth=default_signer())
+            )
+        except Exception:
+            latest_version = {"latest": current_version["installed"]}
+        response = {**current_version, **latest_version}
+        return self.finish(response)
+
+
 class CompatibilityCheckHandler(AquaAPIhandler):
     """The handler to check if the extension is compatible."""
 
@@ -118,4 +162,5 @@ __handlers__ = [
     ("network_status", NetworkStatusHandler),
     ("hf_login", HFLoginHandler),
     ("hf_logged_in", HFUserStatusHandler),
+    ("aqua_version", AquaVersionHandler),
 ]

ads/aqua/extension/model_handler.py

@@ -11,12 +11,15 @@ from ads.aqua.common.decorator import handle_exceptions
 from ads.aqua.common.enums import CustomInferenceContainerTypeFamily
 from ads.aqua.common.errors import AquaRuntimeError
 from ads.aqua.common.utils import get_hf_model_info, is_valid_ocid, list_hf_models
+from ads.aqua.constants import AQUA_CHAT_TEMPLATE_METADATA_KEY
 from ads.aqua.extension.base_handler import AquaAPIhandler
 from ads.aqua.extension.errors import Errors
 from ads.aqua.model import AquaModelApp
 from ads.aqua.model.entities import AquaModelSummary, HFModelSummary
 from ads.config import SERVICE
+from ads.model import DataScienceModel
 from ads.model.common.utils import MetadataArtifactPathType
+from ads.model.service.oci_datascience_model import OCIDataScienceModel
 
 
 class AquaModelHandler(AquaAPIhandler):
@@ -320,26 +323,65 @@ class AquaHuggingFaceHandler(AquaAPIhandler):
         )
 
 
-class AquaModelTokenizerConfigHandler(AquaAPIhandler):
+class AquaModelChatTemplateHandler(AquaAPIhandler):
     def get(self, model_id):
         """
-        Handles requests for retrieving the Hugging Face tokenizer configuration of a specified model.
-        Expected request format: GET /aqua/models/<model-ocid>/tokenizer
+        Handles requests for retrieving the chat template from custom metadata of a specified model.
+        Expected request format: GET /aqua/models/<model-ocid>/chat-template
 
         """
 
         path_list = urlparse(self.request.path).path.strip("/").split("/")
-        # Path should be /aqua/models/ocid1.iad.ahdxxx/tokenizer
-        # path_list=['aqua','models','<model-ocid>','tokenizer']
+        # Path should be /aqua/models/ocid1.iad.ahdxxx/chat-template
+        # path_list=['aqua','models','<model-ocid>','chat-template']
         if (
             len(path_list) == 4
             and is_valid_ocid(path_list[2])
-            and path_list[3] == "tokenizer"
+            and path_list[3] == "chat-template"
         ):
-            return self.finish(AquaModelApp().get_hf_tokenizer_config(model_id))
+            try:
+                oci_data_science_model = OCIDataScienceModel.from_id(model_id)
+            except Exception as e:
+                raise HTTPError(404, f"Model not found for id: {model_id}. Details: {str(e)}")
+            return self.finish(oci_data_science_model.get_custom_metadata_artifact("chat_template"))
 
         raise HTTPError(400, f"The request {self.request.path} is invalid.")
 
+    @handle_exceptions
+    def post(self, model_id: str):
+        """
+        Handles POST requests to add a custom chat_template metadata artifact to a model.
+
+        Expected request format:
+        POST /aqua/models/<model-ocid>/chat-template
+        Body: { "chat_template": "<your_template_string>" }
+
+        """
+        try:
+            input_body = self.get_json_body()
+        except Exception as e:
+            raise HTTPError(400, f"Invalid JSON body: {str(e)}")
+
+        chat_template = input_body.get("chat_template")
+        if not chat_template:
+            raise HTTPError(400, "Missing required field: 'chat_template'")
+
+        try:
+            data_science_model = DataScienceModel.from_id(model_id)
+        except Exception as e:
+            raise HTTPError(404, f"Model not found for id: {model_id}. Details: {str(e)}")
+
+        try:
+            result = data_science_model.create_custom_metadata_artifact(
+                metadata_key_name=AQUA_CHAT_TEMPLATE_METADATA_KEY,
+                path_type=MetadataArtifactPathType.CONTENT,
+                artifact_path_or_content=chat_template.encode()
+            )
+        except Exception as e:
+            raise HTTPError(500, f"Failed to create metadata artifact: {str(e)}")
+
+        return self.finish(result)
+
 
 class AquaModelDefinedMetadataArtifactHandler(AquaAPIhandler):
     """
@@ -381,7 +423,7 @@ __handlers__ = [
     ("model/?([^/]*)", AquaModelHandler),
     ("model/?([^/]*)/license", AquaModelLicenseHandler),
     ("model/?([^/]*)/readme", AquaModelReadmeHandler),
-    ("model/?([^/]*)/tokenizer", AquaModelTokenizerConfigHandler),
+    ("model/?([^/]*)/chat-template", AquaModelChatTemplateHandler),
     ("model/hf/search/?([^/]*)", AquaHuggingFaceHandler),
     (
         "model/?([^/]*)/definedMetadata/?([^/]*)",

ads/aqua/model/constants.py

@@ -26,6 +26,7 @@ class ModelTask(ExtendedEnum):
     TEXT_GENERATION = "text-generation"
     IMAGE_TEXT_TO_TEXT = "image-text-to-text"
     IMAGE_TO_TEXT = "image-to-text"
+    TIME_SERIES_FORECASTING = "time-series-forecasting"
 
 
 class FineTuningMetricCategories(ExtendedEnum):