Endpoints

class Endpoint:
    id: UUID                # Unique identifier
    tenant_id: UUID         # Tenant isolation
    name: str               # Display name
    slug: str               # URL path (unique per tenant)
    description: str        # Markdown documentation
    summary: str            # Brief description
    dataset_id: UUID | None # Linked dataset (optional)
    model_id: UUID | None   # Linked model (optional)
    response_type: str      # "raw", "summary", or "both"
    published: bool         # Whether endpoint is queryable
    tags: str               # Comma-separated tags
    published_to: list[str] # Marketplace IDs where published
    created_at: datetime
    updated_at: datetime

class ResponseType(Enum):
    RAW = "raw"          # Dataset search only
    SUMMARY = "summary"  # Model generation only
    BOTH = "both"        # Dataset search + model generation (RAG)

class QueryEndpointRequest:
    messages: str | list[ChatMessageRequest]  # User input
    similarity_threshold: float = 0.5         # Dataset search threshold
    limit: int = 5                            # Max search results
    include_metadata: bool = True             # Include doc metadata
    max_tokens: int = 100                     # Model max tokens
    temperature: float = 0.7                  # Model temperature
    stop_sequences: list[str] = ["\n"]        # Model stop tokens
    stream: bool = False                      # Streaming mode
    presence_penalty: float = 0.0             # Model penalty
    frequency_penalty: float = 0.0            # Model penalty
    extras: dict = {}                         # Additional options
    transaction_token: str | None = None      # Accounting token

class AuthenticatedQueryRequest(QueryEndpointRequest):
    sender_email: EmailStr  # Extracted from SyftHub token

@field_validator("slug")
def validate_slug(v: str) -> str:
    v = v.lower()
    
    # Length: 3-64 characters
    if len(v) < 3 or len(v) > 64:
        raise ValueError("Slug must be 3-64 characters")
    
    # Pattern: lowercase letters, numbers, hyphens
    # No leading/trailing/consecutive hyphens
    if not re.match(r"^[a-z0-9]+(-[a-z0-9]+)*$", v):
        raise ValueError("Invalid slug format")
    
    return v

async def publish_endpoint(
    slug: str,
    marketplace_ids: list[UUID] | None,
    publish_to_all_marketplaces: bool,
    tenant: Tenant
) -> PublishEndpointResponse:
    """
    1. Validates marketplace exists and is active
    2. Authenticates to marketplace with credentials
    3. Publishes endpoint metadata via SyftHub API
    4. Records publication in endpoint.published_to
    """

{
    "name": endpoint.name,
    "description": endpoint.summary,
    "type": endpoint_type,  # "model_data_source", "model", or "data_source"
    "slug": endpoint.slug,
    "readme": endpoint.description,  # Markdown documentation
    "policies": [...]  # Attached policy configurations
    "connect": [{
        "type": "https",
        "config": {"path": f"/api/v1/endpoints/{slug}/query"}
    }]
}

async def sync_endpoints_to_marketplaces(
    tenant: Tenant
) -> dict[str, list[str]]:
    """
    Groups all published endpoints by marketplace
    Calls sync_endpoints API for each marketplace
    Returns synced endpoint slugs per marketplace
    """

async def create_endpoint(
    request: CreateEndpointRequest,
    tenant: Tenant
) -> EndpointCreateResponse:
    """
    1. Validates at least one of dataset_id or model_id
    2. Checks slug uniqueness
    3. Verifies dataset and model exist (if provided)
    4. Creates endpoint entity
    """

async def update_endpoint(
    slug: str,
    request: UpdateEndpointRequest,
    tenant: Tenant
) -> EndpointDetailResponse:
    """Updates metadata fields only."""

async def delete_endpoint(slug: str, tenant: Tenant) -> dict:
    """
    Deletes endpoint and all attached policies.
    Does NOT delete the linked dataset or model.
    """