feat: deliver agent foundation day 1

server/src/app/api/v1/endpoints/agent_assets.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Header, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_db
+from app.schemas.agent_asset import (
+    AgentAssetCreate,
+    AgentAssetListItem,
+    AgentAssetRead,
+    AgentAssetReviewCreate,
+    AgentAssetReviewRead,
+    AgentAssetUpdate,
+    AgentAssetVersionCreate,
+    AgentAssetVersionRead,
+)
+from app.services.agent_assets import AgentAssetService
+
+router = APIRouter(prefix="/agent-assets")
+DbSession = Annotated[Session, Depends(get_db)]
+
+
+def _handle_asset_error(exc: Exception) -> None:
+    if isinstance(exc, LookupError):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+    if isinstance(exc, PermissionError):
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
+    if isinstance(exc, ValueError):
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
+    raise exc
+
+
+@router.get("", response_model=list[AgentAssetListItem])
+def list_agent_assets(
+    db: DbSession,
+    asset_type: str | None = Query(default=None),
+    status_value: str | None = Query(default=None, alias="status"),
+    domain: str | None = Query(default=None),
+    keyword: str | None = Query(default=None),
+) -> list[AgentAssetListItem]:
+    return AgentAssetService(db).list_assets(
+        asset_type=asset_type,
+        status=status_value,
+        domain=domain,
+        keyword=keyword,
+    )
+
+
+@router.get("/{asset_id}", response_model=AgentAssetRead)
+def get_agent_asset(asset_id: str, db: DbSession) -> AgentAssetRead:
+    asset = AgentAssetService(db).get_asset(asset_id)
+    if asset is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Asset not found")
+    return asset
+
+
+@router.post("", response_model=AgentAssetRead, status_code=status.HTTP_201_CREATED)
+def create_agent_asset(
+    payload: AgentAssetCreate,
+    db: DbSession,
+    x_actor: Annotated[str | None, Header()] = None,
+    x_request_id: Annotated[str | None, Header()] = None,
+) -> AgentAssetRead:
+    try:
+        return AgentAssetService(db).create_asset(
+            payload,
+            actor=(x_actor or payload.owner).strip() or "system",
+            request_id=x_request_id,
+        )
+    except Exception as exc:
+        _handle_asset_error(exc)
+
+
+@router.patch("/{asset_id}", response_model=AgentAssetRead)
+def update_agent_asset(
+    asset_id: str,
+    payload: AgentAssetUpdate,
+    db: DbSession,
+    x_actor: Annotated[str | None, Header()] = None,
+    x_request_id: Annotated[str | None, Header()] = None,
+) -> AgentAssetRead:
+    try:
+        return AgentAssetService(db).update_asset(
+            asset_id,
+            payload,
+            actor=(x_actor or "system").strip() or "system",
+            request_id=x_request_id,
+        )
+    except Exception as exc:
+        _handle_asset_error(exc)
+
+
+@router.get("/{asset_id}/versions", response_model=list[AgentAssetVersionRead])
+def list_agent_asset_versions(
+    asset_id: str, db: DbSession, limit: int = Query(default=20, ge=1, le=100)
+) -> list[AgentAssetVersionRead]:
+    try:
+        return AgentAssetService(db).list_versions(asset_id, limit=limit)
+    except Exception as exc:
+        _handle_asset_error(exc)
+
+
+@router.post(
+    "/{asset_id}/versions",
+    response_model=AgentAssetVersionRead,
+    status_code=status.HTTP_201_CREATED,
+)
+def create_agent_asset_version(
+    asset_id: str,
+    payload: AgentAssetVersionCreate,
+    db: DbSession,
+    x_actor: Annotated[str | None, Header()] = None,
+    x_request_id: Annotated[str | None, Header()] = None,
+) -> AgentAssetVersionRead:
+    try:
+        return AgentAssetService(db).create_version(
+            asset_id,
+            payload,
+            actor=(x_actor or payload.created_by).strip() or "system",
+            request_id=x_request_id,
+        )
+    except Exception as exc:
+        _handle_asset_error(exc)
+
+
+@router.post(
+    "/{asset_id}/reviews", response_model=AgentAssetReviewRead, status_code=status.HTTP_201_CREATED
+)
+def create_agent_asset_review(
+    asset_id: str,
+    payload: AgentAssetReviewCreate,
+    db: DbSession,
+    x_actor: Annotated[str | None, Header()] = None,
+    x_request_id: Annotated[str | None, Header()] = None,
+) -> AgentAssetReviewRead:
+    try:
+        return AgentAssetService(db).create_review(
+            asset_id,
+            payload,
+            actor=(x_actor or payload.reviewer).strip() or "system",
+            request_id=x_request_id,
+        )
+    except Exception as exc:
+        _handle_asset_error(exc)
+
+
+@router.post("/{asset_id}/activate", response_model=AgentAssetRead)
+def activate_agent_asset(
+    asset_id: str,
+    db: DbSession,
+    x_actor: Annotated[str | None, Header()] = None,
+    x_request_id: Annotated[str | None, Header()] = None,
+) -> AgentAssetRead:
+    try:
+        return AgentAssetService(db).activate_asset(
+            asset_id,
+            actor=(x_actor or "system").strip() or "system",
+            request_id=x_request_id,
+        )
+    except Exception as exc:
+        _handle_asset_error(exc)

server/src/app/api/v1/endpoints/agent_runs.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_db
+from app.schemas.agent_run import AgentRunRead
+from app.services.agent_runs import AgentRunService
+
+router = APIRouter(prefix="/agent-runs")
+DbSession = Annotated[Session, Depends(get_db)]
+
+
+@router.get("", response_model=list[AgentRunRead])
+def list_agent_runs(
+    db: DbSession,
+    agent: str | None = Query(default=None),
+    status_value: str | None = Query(default=None, alias="status"),
+    source: str | None = Query(default=None),
+    limit: int = Query(default=20, ge=1, le=100),
+) -> list[AgentRunRead]:
+    return AgentRunService(db).list_runs(
+        agent=agent, status=status_value, source=source, limit=limit
+    )
+
+
+@router.get("/{run_id}", response_model=AgentRunRead)
+def get_agent_run(run_id: str, db: DbSession) -> AgentRunRead:
+    run = AgentRunService(db).get_run(run_id)
+    if run is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Run not found")
+    return run

server/src/app/api/v1/endpoints/audit_logs.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_db
+from app.schemas.audit_log import AuditLogRead
+from app.services.audit import AuditLogService
+
+router = APIRouter(prefix="/audit-logs")
+DbSession = Annotated[Session, Depends(get_db)]
+
+
+@router.get("", response_model=list[AuditLogRead])
+def list_audit_logs(
+    db: DbSession,
+    resource_type: str | None = Query(default=None),
+    resource_id: str | None = Query(default=None),
+    action: str | None = Query(default=None),
+    limit: int = Query(default=50, ge=1, le=200),
+) -> list[AuditLogRead]:
+    return AuditLogService(db).list_logs(
+        resource_type=resource_type,
+        resource_id=resource_id,
+        action=action,
+        limit=limit,
+    )

server/src/app/api/v1/router.py

@@ -1,18 +1,24 @@
-from fastapi import APIRouter
-
-from app.api.v1.endpoints.auth import router as auth_router
-from app.api.v1.endpoints.bootstrap import router as bootstrap_router
-from app.api.v1.endpoints.employees import router as employees_router
-from app.api.v1.endpoints.health import router as health_router
-from app.api.v1.endpoints.knowledge import router as knowledge_router
+from fastapi import APIRouter
+
+from app.api.v1.endpoints.agent_assets import router as agent_assets_router
+from app.api.v1.endpoints.agent_runs import router as agent_runs_router
+from app.api.v1.endpoints.audit_logs import router as audit_logs_router
+from app.api.v1.endpoints.auth import router as auth_router
+from app.api.v1.endpoints.bootstrap import router as bootstrap_router
+from app.api.v1.endpoints.employees import router as employees_router
+from app.api.v1.endpoints.health import router as health_router
+from app.api.v1.endpoints.knowledge import router as knowledge_router
 from app.api.v1.endpoints.reimbursements import router as reimbursements_router
 from app.api.v1.endpoints.settings import router as settings_router
 
-router = APIRouter()
-router.include_router(health_router, tags=["health"])
-router.include_router(bootstrap_router, tags=["bootstrap"])
-router.include_router(auth_router, tags=["auth"])
-router.include_router(knowledge_router, tags=["knowledge"])
-router.include_router(employees_router, prefix="/employees", tags=["employees"])
-router.include_router(reimbursements_router, prefix="/reimbursements", tags=["reimbursements"])
-router.include_router(settings_router, tags=["settings"])
+router = APIRouter()
+router.include_router(health_router, tags=["health"])
+router.include_router(bootstrap_router, tags=["bootstrap"])
+router.include_router(auth_router, tags=["auth"])
+router.include_router(agent_assets_router, tags=["agent-assets"])
+router.include_router(agent_runs_router, tags=["agent-runs"])
+router.include_router(audit_logs_router, tags=["audit-logs"])
+router.include_router(knowledge_router, tags=["knowledge"])
+router.include_router(employees_router, prefix="/employees", tags=["employees"])
+router.include_router(reimbursements_router, prefix="/reimbursements", tags=["reimbursements"])
+router.include_router(settings_router, tags=["settings"])