QuickLab-MCP 0.1.0__py3-none-any.whl

ml_mcp/application/models/service.py

@@ -0,0 +1,177 @@
+"""Model catalog application service."""
+
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ml_mcp.application.models.catalog_seed import APPROVED_MODELS
+from ml_mcp.domain.errors import (
+    ModelNotApprovedError,
+    ResourceNotFoundError,
+    ResourceVersionRevokedError,
+)
+from ml_mcp.domain.value_objects import ApprovalStatus
+from ml_mcp.infrastructure.postgres.base import generate_uuid7
+from ml_mcp.infrastructure.postgres.models import ModelOrm, ModelVersionOrm
+from ml_mcp.infrastructure.postgres.repositories.models import ModelRepository
+
+
+class ModelService:
+    """Service managing approved ML model architectures and hyperparameter contracts."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+        self.repo = ModelRepository(session)
+
+    async def seed_catalog(self) -> None:
+        """Seed all 7 approved tabular models and versions if missing, or synchronize digests."""
+        for meta in APPROVED_MODELS:
+            existing = await self.repo.get_by_id(meta.model_id)
+            if not existing:
+                model_orm = ModelOrm(
+                    id=meta.model_id,
+                    tenant_id="system",
+                    name=meta.name,
+                    description=meta.description,
+                    family=meta.family.value,
+                    publisher=meta.publisher,
+                )
+                await self.repo.create_model(model_orm)
+            else:
+                existing.name = meta.name
+                existing.description = meta.description
+                existing.family = meta.family.value
+
+            existing_version = await self.repo.get_version(meta.model_id, meta.version)
+            if not existing_version:
+                version_orm = ModelVersionOrm(
+                    id=generate_uuid7(),
+                    model_id=meta.model_id,
+                    version=meta.version,
+                    container_image_digest=meta.container_image_digest,
+                    supported_task_types=[t.value for t in meta.supported_task_types],
+                    hyperparameters_schema=[h.model_dump() for h in meta.supported_hyperparameters],
+                    approval_status=meta.approval_status.value,
+                )
+                await self.repo.create_version(version_orm)
+            else:
+                existing_version.container_image_digest = meta.container_image_digest
+                existing_version.supported_task_types = [t.value for t in meta.supported_task_types]
+                existing_version.hyperparameters_schema = [h.model_dump() for h in meta.supported_hyperparameters]
+                existing_version.approval_status = meta.approval_status.value
+
+    async def list_models(self) -> list[dict[str, Any]]:
+        models = await self.repo.list_models()
+        return [
+            {
+                "model_id": m.id,
+                "name": m.name,
+                "description": m.description,
+                "family": m.family,
+                "publisher": m.publisher,
+                "versions": [v.version for v in m.versions if v.approval_status == ApprovalStatus.APPROVED.value],
+            }
+            for m in models
+        ]
+
+    async def get_model(self, model_id: str) -> dict[str, Any]:
+        model = await self.repo.get_by_id(model_id)
+        if not model:
+            raise ResourceNotFoundError("Model", model_id)
+
+        return {
+            "model_id": model.id,
+            "name": model.name,
+            "description": model.description,
+            "family": model.family,
+            "publisher": model.publisher,
+            "versions": [
+                {
+                    "version_id": v.id,
+                    "version": v.version,
+                    "container_image_digest": v.container_image_digest,
+                    "supported_task_types": v.supported_task_types,
+                    "hyperparameters_schema": v.hyperparameters_schema,
+                    "approval_status": v.approval_status,
+                }
+                for v in model.versions
+            ],
+        }
+
+    async def list_model_versions(self, model_id: str) -> list[dict[str, Any]]:
+        versions = await self.repo.list_versions(model_id)
+        if not versions:
+            raise ResourceNotFoundError("Model", model_id)
+
+        return [
+            {
+                "version_id": v.id,
+                "version": v.version,
+                "approval_status": v.approval_status,
+                "supported_task_types": v.supported_task_types,
+                "container_image_digest": v.container_image_digest,
+            }
+            for v in versions
+        ]
+
+    async def validate_model_for_experiment(
+        self,
+        task_type: str | None = None,
+        hyperparameters: dict[str, Any] | None = None,
+        model_version_id: str | None = None,
+        model_id: str | None = None,
+        version: str | None = None,
+        **kwargs: Any,
+    ) -> ModelVersionOrm:
+        """Verify model approval, task compatibility, and hyperparameter bounds."""
+        resolved_task_type = task_type or kwargs.get("task_type")
+        resolved_hypers = hyperparameters if hyperparameters is not None else kwargs.get("hyperparameters", {})
+        resolved_model_id = model_id or kwargs.get("model_id")
+        resolved_version = version or kwargs.get("version")
+        resolved_mv_id = model_version_id or kwargs.get("model_version_id")
+
+        if resolved_mv_id:
+            v = await self.repo.get_version_by_id(resolved_mv_id)
+        elif resolved_model_id and resolved_version:
+            v = await self.repo.get_version(resolved_model_id, resolved_version)
+        else:
+            raise ResourceNotFoundError("ModelVersion", resolved_mv_id or f"{resolved_model_id}:{resolved_version}")
+
+        if not v:
+            raise ResourceNotFoundError("ModelVersion", resolved_mv_id or f"{resolved_model_id}:{resolved_version}")
+
+        mid = resolved_model_id or v.model_id
+        ver = resolved_version or v.version
+
+        if v.approval_status == ApprovalStatus.REVOKED.value:
+            raise ResourceVersionRevokedError("Model", f"{mid}:{ver}")
+
+        if v.approval_status != ApprovalStatus.APPROVED.value:
+            raise ModelNotApprovedError(mid, ver)
+
+        if resolved_task_type and resolved_task_type not in v.supported_task_types:
+            raise ValueError(
+                f"Model '{mid}' does not support task type '{resolved_task_type}'. Supported: {v.supported_task_types}"
+            )
+
+        # Validate hyperparameter constraints
+        schema_map = {item["name"]: item for item in v.hyperparameters_schema}
+        for param_name, param_val in resolved_hypers.items():
+            if param_name not in schema_map:
+                continue  # Allow extra params or warn
+            constraint = schema_map[param_name]
+            # Range validation
+            if constraint.get("min_value") is not None and param_val < constraint["min_value"]:
+                raise ValueError(
+                    f"Hyperparameter '{param_name}' value {param_val} < minimum {constraint['min_value']}"
+                )
+            if constraint.get("max_value") is not None and param_val > constraint["max_value"]:
+                raise ValueError(
+                    f"Hyperparameter '{param_name}' value {param_val} > maximum {constraint['max_value']}"
+                )
+            if constraint.get("allowed_values") and param_val not in constraint["allowed_values"]:
+                raise ValueError(
+                    f"Hyperparameter '{param_name}' value {param_val} not in allowed: {constraint['allowed_values']}"
+                )
+
+        return v

ml_mcp/application/projects/__init__.py

@@ -0,0 +1,5 @@
+"""Projects application package."""
+
+from ml_mcp.application.projects.service import ProjectService
+
+__all__ = ["ProjectService"]

ml_mcp/application/projects/service.py

@@ -0,0 +1,93 @@
+"""Project management application service."""
+
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ml_mcp.domain.errors import InvalidInputError, ResourceNotFoundError
+from ml_mcp.infrastructure.postgres.base import generate_uuid7
+from ml_mcp.infrastructure.postgres.models import ProjectOrm
+from ml_mcp.infrastructure.postgres.repositories.projects import ProjectRepository
+
+
+class ProjectService:
+    """Service coordinating project creation, retrieval, and defaults."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+        self.repo = ProjectRepository(session)
+
+    async def create_project(
+        self,
+        tenant_id: str,
+        name: str,
+        description: str = "",
+    ) -> dict[str, Any]:
+        """Create a new project under the specified tenant."""
+        clean_name = name.strip()
+        if not clean_name:
+            raise InvalidInputError("Project name cannot be empty.")
+
+        existing = await self.repo.get_project_by_name(tenant_id, clean_name)
+        if existing:
+            raise InvalidInputError(f"Project with name '{clean_name}' already exists.")
+
+        project = ProjectOrm(
+            id=generate_uuid7(),
+            tenant_id=tenant_id,
+            name=clean_name,
+            description=description.strip(),
+        )
+        saved = await self.repo.create_project(project)
+        return {
+            "project_id": saved.id,
+            "name": saved.name,
+            "description": saved.description,
+            "tenant_id": saved.tenant_id,
+            "created_at": saved.created_at.isoformat(),
+        }
+
+    async def get_project(self, tenant_id: str, project_id: str) -> dict[str, Any]:
+        """Retrieve project by ID or raise ResourceNotFoundError."""
+        project = await self.repo.get_project(tenant_id, project_id)
+        if not project:
+            raise ResourceNotFoundError("Project", project_id)
+        return {
+            "project_id": project.id,
+            "name": project.name,
+            "description": project.description,
+            "tenant_id": project.tenant_id,
+            "created_at": project.created_at.isoformat(),
+        }
+
+    async def list_projects(
+        self,
+        tenant_id: str,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """List all projects belonging to the tenant."""
+        projects = await self.repo.list_projects(tenant_id, limit=limit, offset=offset)
+        return [
+            {
+                "project_id": p.id,
+                "name": p.name,
+                "description": p.description,
+                "tenant_id": p.tenant_id,
+                "created_at": p.created_at.isoformat(),
+            }
+            for p in projects
+        ]
+
+    async def ensure_default_project(
+        self, tenant_id: str = "default-tenant"
+    ) -> dict[str, Any]:
+        """Ensure the tenant and default-project exist, returning its details."""
+        default_proj = await self.repo.get_or_create_default_project(tenant_id)
+        return {
+            "project_id": default_proj.id,
+            "name": default_proj.name,
+            "description": default_proj.description,
+            "tenant_id": default_proj.tenant_id,
+            "created_at": default_proj.created_at.isoformat(),
+        }

ml_mcp/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration module for ML-MCP server."""
+
+from ml_mcp.config.settings import Settings, get_settings
+
+__all__ = ["Settings", "get_settings"]

ml_mcp/config/settings.py

@@ -0,0 +1,176 @@
+"""Centralized production configuration using Pydantic Settings."""
+
+from functools import lru_cache
+from typing import Literal
+
+from dotenv import load_dotenv
+from pydantic import Field, SecretStr, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# Load local .env to prioritize ModelLab local services over host environment variables
+load_dotenv(override=True)
+
+
+
+class AppSettings(BaseSettings):
+    """Application level configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="APP_", extra="ignore")
+
+    name: str = "ml-mcp"
+    env: Literal["development", "staging", "production", "testing"] = "development"
+    debug: bool = False
+    secret_key: SecretStr = Field(
+        default=SecretStr("insecure-dev-secret-key-change-in-production-min32bytes"),
+        description="Master cryptographic key for token signing or derivation",
+    )
+
+
+class McpSettings(BaseSettings):
+    """MCP protocol and transport settings."""
+
+    model_config = SettingsConfigDict(env_prefix="MCP_", extra="ignore")
+
+    server_name: str = "ModelLab-ML-MCP"
+    server_version: str = "0.1.0"
+    protocol_version: str = "2026-07-28"
+    host: str = "127.0.0.1"
+    port: int = 8000
+    streamable_http_path: str = "/mcp"
+
+
+class AuthSettings(BaseSettings):
+    """Authentication and OIDC configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="AUTH_", extra="ignore")
+
+    enabled: bool = True
+    issuer: str = "https://auth.modellab.local"
+    audience: str = "modellab-mcp-api"
+    algorithms: list[str] = ["RS256", "HS256"]
+    secret_key: SecretStr = Field(
+        default=SecretStr("dev-jwt-secret-key-min-32-characters-long-production-change"),
+        description="Secret key for symmetric JWT algorithms like HS256",
+    )
+    public_key_pem: str | None = None
+    jwks_url: str | None = None
+
+
+class DatabaseSettings(BaseSettings):
+    """PostgreSQL database configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="DATABASE_", extra="ignore")
+
+    url: str = "postgresql+asyncpg://postgres:postgres@localhost:5432/modellab"
+    pool_size: int = 10
+    max_overflow: int = 20
+    pool_timeout: float = 30.0
+    pool_recycle: int = 1800
+    echo: bool = False
+
+    @field_validator("url", mode="after")
+    @classmethod
+    def ensure_asyncpg_driver(cls, v: str) -> str:
+        if v.startswith("postgresql://"):
+            return v.replace("postgresql://", "postgresql+asyncpg://", 1)
+        return v
+
+
+
+class RedisSettings(BaseSettings):
+    """Redis / Valkey configuration for caching, rate limiting, and queues."""
+
+    model_config = SettingsConfigDict(env_prefix="REDIS_", extra="ignore")
+
+    url: str = "redis://localhost:6379/0"
+    max_connections: int = 20
+    task_queue_name: str = "ml_mcp:tasks:experiments"
+    retry_backoff_seconds: float = 2.0
+
+
+class ObjectStoreSettings(BaseSettings):
+    """S3-compatible object storage configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="OBJECT_STORE_", extra="ignore")
+
+    endpoint_url: str | None = "http://localhost:9000"
+    access_key_id: SecretStr = Field(default=SecretStr("minioadmin"))
+    secret_access_key: SecretStr = Field(default=SecretStr("minioadmin"))
+    bucket_name: str = "modellab-artifacts"
+    region: str = "us-east-1"
+    presigned_ttl_seconds: int = 900
+
+
+class WorkerSettings(BaseSettings):
+    """ML Worker execution policy and resources."""
+
+    model_config = SettingsConfigDict(env_prefix="WORKER_", extra="ignore")
+
+    in_process: bool = True
+    max_concurrent_experiments: int = 4
+    default_timeout_seconds: int = 1800
+    max_memory_mb: int = 4096
+    tmp_dir: str = "./tmp/worker"
+
+
+class RateLimitSettings(BaseSettings):
+    """Layered rate limiting thresholds (requests per minute)."""
+
+    model_config = SettingsConfigDict(env_prefix="RATE_LIMIT_", extra="ignore")
+
+    read_per_minute: int = 120
+    metadata_per_minute: int = 60
+    experiment_per_minute: int = 10
+    analysis_per_minute: int = 20
+
+
+class OtelSettings(BaseSettings):
+    """OpenTelemetry configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="OTEL_", extra="ignore")
+
+    enabled: bool = False
+    service_name: str = "ml-mcp-service"
+    exporter_otlp_endpoint: str = "http://localhost:4317"
+
+
+class SecuritySettings(BaseSettings):
+    """Input limits and security bounds."""
+
+    model_config = SettingsConfigDict(env_prefix="SECURITY_", extra="ignore")
+
+    max_request_body_bytes: int = 10 * 1024 * 1024  # 10 MB
+    max_dataset_upload_bytes: int = 100 * 1024 * 1024  # 100 MB
+    max_dataset_rows: int = 5_000_000
+    max_dataset_columns: int = 1_000
+
+
+class Settings(BaseSettings):
+    """Master aggregated settings."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    app: AppSettings = Field(default_factory=AppSettings)
+    mcp: McpSettings = Field(default_factory=McpSettings)
+    auth: AuthSettings = Field(default_factory=AuthSettings)
+    database: DatabaseSettings = Field(default_factory=DatabaseSettings)
+    redis: RedisSettings = Field(default_factory=RedisSettings)
+    object_store: ObjectStoreSettings = Field(default_factory=ObjectStoreSettings)
+    worker: WorkerSettings = Field(default_factory=WorkerSettings)
+    rate_limit: RateLimitSettings = Field(default_factory=RateLimitSettings)
+    otel: OtelSettings = Field(default_factory=OtelSettings)
+    security: SecuritySettings = Field(default_factory=SecuritySettings)
+
+    @property
+    def app_env(self) -> str:
+        return self.app.env
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> Settings:
+    """Return cached singleton Settings instance."""
+    return Settings()

ml_mcp/domain/__init__.py

@@ -0,0 +1 @@
+"""Domain layer package for ModelLab ML-MCP."""

ml_mcp/domain/errors/__init__.py

@@ -0,0 +1,39 @@
+"""Domain errors package."""
+
+from ml_mcp.domain.errors.base import (
+    ArtifactAccessDeniedError,
+    AuthenticationRequiredError,
+    AuthorizationDeniedError,
+    DatasetValidationError,
+    DependencyUnavailableError,
+    DomainError,
+    ExperimentAlreadyExistsError,
+    ExperimentNotCancellableError,
+    InvalidExperimentError,
+    InvalidInputError,
+    ModelNotApprovedError,
+    ResourceLimitExceededError,
+    ResourceNotFoundError,
+    ResourceVersionRevokedError,
+    TaskUnavailableError,
+)
+from ml_mcp.domain.errors.codes import ErrorCode
+
+__all__ = [
+    "ErrorCode",
+    "DomainError",
+    "AuthenticationRequiredError",
+    "AuthorizationDeniedError",
+    "ResourceNotFoundError",
+    "ResourceVersionRevokedError",
+    "InvalidExperimentError",
+    "InvalidInputError",
+    "DatasetValidationError",
+    "ModelNotApprovedError",
+    "ExperimentAlreadyExistsError",
+    "ExperimentNotCancellableError",
+    "TaskUnavailableError",
+    "ArtifactAccessDeniedError",
+    "ResourceLimitExceededError",
+    "DependencyUnavailableError",
+]

ml_mcp/domain/errors/base.py

@@ -0,0 +1,155 @@
+"""Domain exceptions with sanitized public messages and structured error codes."""
+
+from typing import Any
+
+from ml_mcp.domain.errors.codes import ErrorCode
+
+
+class DomainError(Exception):
+    """Base domain exception that never leaks internal sensitive details to external clients."""
+
+    def __init__(
+        self,
+        code: ErrorCode,
+        message: str,
+        details: dict[str, Any] | None = None,
+        status_code: int = 400,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.details = details or {}
+        self.status_code = status_code
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return safe, machine-readable dictionary representation for API / MCP responses."""
+        payload: dict[str, Any] = {
+            "error_code": self.code.value,
+            "message": self.message,
+        }
+        if self.details:
+            payload["details"] = self.details
+        return payload
+
+
+class AuthenticationRequiredError(DomainError):
+    def __init__(
+        self,
+        message: str = "Authentication required to perform this action",
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(ErrorCode.AUTHENTICATION_REQUIRED, message, details, status_code=401)
+
+
+class AuthorizationDeniedError(DomainError):
+    def __init__(
+        self,
+        message: str = "Access denied for the requested resource",
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(ErrorCode.AUTHORIZATION_DENIED, message, details, status_code=403)
+
+
+class ResourceNotFoundError(DomainError):
+    def __init__(self, resource_type: str, resource_id: str) -> None:
+        super().__init__(
+            ErrorCode.RESOURCE_NOT_FOUND,
+            f"{resource_type} '{resource_id}' was not found",
+            details={"resource_type": resource_type, "resource_id": resource_id},
+            status_code=404,
+        )
+
+
+class ResourceVersionRevokedError(DomainError):
+    def __init__(self, resource_type: str, version: str) -> None:
+        super().__init__(
+            ErrorCode.RESOURCE_VERSION_REVOKED,
+            f"{resource_type} version '{version}' has been revoked",
+            details={"resource_type": resource_type, "version": version},
+            status_code=410,
+        )
+
+
+class InvalidExperimentError(DomainError):
+    def __init__(self, message: str, details: dict[str, Any] | None = None) -> None:
+        super().__init__(ErrorCode.INVALID_EXPERIMENT, message, details, status_code=422)
+
+
+class DatasetValidationError(DomainError):
+    def __init__(self, message: str, details: dict[str, Any] | None = None) -> None:
+        super().__init__(ErrorCode.DATASET_VALIDATION_FAILED, message, details, status_code=422)
+
+
+class ModelNotApprovedError(DomainError):
+    def __init__(self, model_id: str, version: str) -> None:
+        super().__init__(
+            ErrorCode.MODEL_NOT_APPROVED,
+            f"Model '{model_id}' version '{version}' is not approved for execution",
+            details={"model_id": model_id, "version": version},
+            status_code=403,
+        )
+
+
+class ExperimentAlreadyExistsError(DomainError):
+    def __init__(self, experiment_id: str) -> None:
+        super().__init__(
+            ErrorCode.EXPERIMENT_ALREADY_EXISTS,
+            f"Experiment '{experiment_id}' already exists",
+            details={"experiment_id": experiment_id},
+            status_code=409,
+        )
+
+
+class ExperimentNotCancellableError(DomainError):
+    def __init__(self, experiment_id: str, current_status: str) -> None:
+        super().__init__(
+            ErrorCode.EXPERIMENT_NOT_CANCELLABLE,
+            f"Experiment '{experiment_id}' in status '{current_status}' cannot be cancelled",
+            details={"experiment_id": experiment_id, "current_status": current_status},
+            status_code=409,
+        )
+
+
+class TaskUnavailableError(DomainError):
+    def __init__(self, message: str = "Execution task or worker is currently unavailable") -> None:
+        super().__init__(ErrorCode.TASK_UNAVAILABLE, message, status_code=503)
+
+
+class ArtifactAccessDeniedError(DomainError):
+    def __init__(self, artifact_id: str) -> None:
+        super().__init__(
+            ErrorCode.ARTIFACT_ACCESS_DENIED,
+            f"Access to artifact '{artifact_id}' is denied",
+            details={"artifact_id": artifact_id},
+            status_code=403,
+        )
+
+
+class ResourceLimitExceededError(DomainError):
+    def __init__(self, resource: str, limit: Any, current: Any) -> None:
+        super().__init__(
+            ErrorCode.RESOURCE_LIMIT_EXCEEDED,
+            f"Resource limit exceeded for '{resource}': limit is {limit}, requested/current is {current}",
+            details={"resource": resource, "limit": limit, "current": current},
+            status_code=429,
+        )
+
+
+class DependencyUnavailableError(DomainError):
+    def __init__(self, dependency: str) -> None:
+        super().__init__(
+            ErrorCode.DEPENDENCY_UNAVAILABLE,
+            f"Dependent service '{dependency}' is currently unavailable",
+            details={"dependency": dependency},
+            status_code=503,
+        )
+
+
+class InvalidInputError(DomainError):
+    def __init__(self, message: str = "Invalid input provided", details: dict[str, Any] | None = None) -> None:
+        super().__init__(
+            ErrorCode.INVALID_INPUT,
+            message,
+            details=details,
+            status_code=400,
+        )

ml_mcp/domain/errors/codes.py

@@ -0,0 +1,23 @@
+"""Stable, machine-readable error codes for the ML-MCP domain."""
+
+from enum import StrEnum
+
+
+class ErrorCode(StrEnum):
+    """Enumeration of standardized domain error codes."""
+
+    AUTHENTICATION_REQUIRED = "AUTHENTICATION_REQUIRED"
+    AUTHORIZATION_DENIED = "AUTHORIZATION_DENIED"
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND"
+    RESOURCE_VERSION_REVOKED = "RESOURCE_VERSION_REVOKED"
+    INVALID_EXPERIMENT = "INVALID_EXPERIMENT"
+    DATASET_VALIDATION_FAILED = "DATASET_VALIDATION_FAILED"
+    MODEL_NOT_APPROVED = "MODEL_NOT_APPROVED"
+    EXPERIMENT_ALREADY_EXISTS = "EXPERIMENT_ALREADY_EXISTS"
+    EXPERIMENT_NOT_CANCELLABLE = "EXPERIMENT_NOT_CANCELLABLE"
+    TASK_UNAVAILABLE = "TASK_UNAVAILABLE"
+    ARTIFACT_ACCESS_DENIED = "ARTIFACT_ACCESS_DENIED"
+    RESOURCE_LIMIT_EXCEEDED = "RESOURCE_LIMIT_EXCEEDED"
+    DEPENDENCY_UNAVAILABLE = "DEPENDENCY_UNAVAILABLE"
+    INVALID_INPUT = "INVALID_INPUT"
+    INTERNAL_ERROR = "INTERNAL_ERROR"