upload

backend/app/api/capabilities/__init__.py

@@ -0,0 +1 @@
+

backend/app/api/capabilities/create_composite_capability.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, Request, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database.session import get_session
+from app.models import User, UserRole
+from app.schemas.capability_sch import CapabilityResponse, CreateCompositeCapabilityRequest
+from app.services.capability_service import (
+    CapabilityService,
+    CompositeRecipeValidationError,
+)
+from app.utils.business_logger import log_business_event
+from app.utils.token_manager import get_current_user
+
+
+router = APIRouter(tags=["Capabilities"])
+
+
+@router.post(
+    "/composite",
+    response_model=CapabilityResponse,
+    status_code=status.HTTP_201_CREATED,
+)
+async def create_composite_capability(
+    payload: CreateCompositeCapabilityRequest,
+    request: Request,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_user),
+):
+    trace_id = getattr(request.state, "traceId", None)
+    capability_service = CapabilityService(session)
+    try:
+        capability = await capability_service.create_validated_composite_capability(
+            owner_user_id=current_user.id,
+            name=payload.name,
+            description=payload.description,
+            input_schema=payload.input_schema,
+            output_schema=payload.output_schema,
+            recipe=payload.recipe.model_dump(mode="python"),
+            include_all=current_user.role == UserRole.ADMIN,
+        )
+        await session.commit()
+        await session.refresh(capability)
+        recipe_dump = payload.recipe.model_dump(mode="python")
+        recipe_steps = recipe_dump.get("steps") if isinstance(recipe_dump, dict) else None
+        log_business_event(
+            "composite_capability_created",
+            trace_id=trace_id,
+            user_id=str(current_user.id),
+            capability_id=str(capability.id),
+            capability_name=capability.name,
+            recipe_steps_count=len(recipe_steps) if isinstance(recipe_steps, list) else None,
+        )
+        return capability
+    except CompositeRecipeValidationError as exc:
+        await session.rollback()
+        log_business_event(
+            "composite_capability_rejected",
+            trace_id=trace_id,
+            user_id=str(current_user.id),
+            capability_name=payload.name,
+            reason="validation_failed",
+            errors_count=len(exc.errors),
+        )
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail={
+                "message": "Composite recipe validation failed",
+                "errors": exc.errors,
+            },
+        ) from exc

backend/app/api/capabilities/dependencies.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from uuid import UUID
+
+from fastapi import HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models import Capability, User, UserRole
+from app.services.capability_service import CapabilityService
+
+
+async def get_capability_or_404(
+    session: AsyncSession,
+    capability_id: UUID,
+    current_user: User,
+) -> Capability:
+    capability_service = CapabilityService(session)
+    capability = await capability_service.get_capability(
+        capability_id,
+        owner_user_id=current_user.id,
+        include_all=current_user.role == UserRole.ADMIN,
+    )
+    if capability is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Capability not found")
+    return capability

backend/app/api/capabilities/get_capability.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.capabilities.dependencies import get_capability_or_404
+from app.core.database.session import get_session
+from app.models import User
+from app.schemas.capability_sch import CapabilityResponse
+from app.utils.business_logger import log_business_event
+from app.utils.token_manager import get_current_user
+
+
+router = APIRouter(tags=["Capabilities"])
+
+
+@router.get("/{capability_id}", response_model=CapabilityResponse)
+async def get_capability(
+    capability_id: UUID,
+    request: Request,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_user),
+):
+    trace_id = getattr(request.state, "traceId", None)
+    try:
+        capability = await get_capability_or_404(session, capability_id, current_user)
+    except HTTPException:
+        log_business_event(
+            "capability_fetch_rejected",
+            trace_id=trace_id,
+            user_id=str(current_user.id),
+            capability_id=str(capability_id),
+            reason="capability_not_found_or_forbidden",
+        )
+        raise
+
+    log_business_event(
+        "capability_fetched",
+        trace_id=trace_id,
+        user_id=str(current_user.id),
+        capability_id=str(capability.id),
+        capability_type=capability.type.value if hasattr(capability.type, "value") else str(capability.type),
+    )
+    return capability

backend/app/api/capabilities/list_capabilities.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, Query, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database.session import get_session
+from app.models import User, UserRole
+from app.schemas.capability_sch import CapabilityResponse
+from app.services.capability_service import CapabilityService
+from app.utils.business_logger import log_business_event
+from app.utils.token_manager import get_current_user
+
+
+router = APIRouter(tags=["Capabilities"])
+
+
+@router.get("/", response_model=list[CapabilityResponse])
+async def list_capabilities(
+    request: Request,
+    action_id: UUID | None = Query(default=None),
+    owner_id: UUID | None = Query(default=None),
+    limit: int = Query(default=50, ge=1, le=200),
+    offset: int = Query(default=0, ge=0),
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_user),
+):
+    trace_id = getattr(request.state, "traceId", None)
+    capability_service = CapabilityService(session)
+    action_ids = [action_id] if action_id is not None else None
+    include_all = current_user.role == UserRole.ADMIN
+    owner_user_id = owner_id if include_all and owner_id is not None else current_user.id
+
+    capabilities = await capability_service.get_capabilities(
+        action_ids=action_ids,
+        owner_user_id=owner_user_id,
+        include_all=include_all and owner_id is None,
+        limit=limit,
+        offset=offset,
+    )
+
+    log_business_event(
+        "capabilities_listed",
+        trace_id=trace_id,
+        user_id=str(current_user.id),
+        owner_id=str(owner_user_id) if owner_user_id is not None else None,
+        action_id=str(action_id) if action_id is not None else None,
+        include_all=include_all and owner_id is None,
+        limit=limit,
+        offset=offset,
+        result_count=len(capabilities),
+    )
+
+    return capabilities

backend/app/api/capabilities/router.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+
+from app.api.capabilities.create_composite_capability import (
+    router as create_composite_capability_router,
+)
+from app.api.capabilities.get_capability import router as get_capability_router
+from app.api.capabilities.list_capabilities import router as list_capabilities_router
+
+
+router = APIRouter(prefix="/v1/capabilities", tags=["Capabilities"])
+router.include_router(list_capabilities_router)
+router.include_router(create_composite_capability_router)
+router.include_router(get_capability_router)