235 lines
9.6 KiB
Python
235 lines
9.6 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
from typing import Any
|
|
|
|
from fastapi import FastAPI, File, HTTPException, UploadFile
|
|
from fastapi.responses import JSONResponse, StreamingResponse
|
|
|
|
from app.models.contracts import ChatRequest, ConversationPatch, ModifyRequest, ParameterUpdate
|
|
from app.services.engine_service import apply_parameter_updates, build_revision
|
|
from app.services.agent_service import AgentService
|
|
from app.services.library import CdslLibrary
|
|
from app.services.storage import WorkspaceStore, safe_conversation_id, safe_task_id
|
|
from app.services.attachments import attachment_record, classify_upload, extract_document_text
|
|
from app.settings import get_settings
|
|
|
|
|
|
settings = get_settings()
|
|
store = WorkspaceStore(settings)
|
|
library = CdslLibrary(settings)
|
|
agent = AgentService(settings, store, library)
|
|
app = FastAPI(title="CDSL CAD Agent API", version="0.1.0")
|
|
|
|
|
|
@app.get("/health")
|
|
async def health() -> dict[str, Any]:
|
|
return {
|
|
"ok": True,
|
|
"service": "cdsl-cad-backend",
|
|
"llm_configured": settings.llm_configured,
|
|
"library_index": (settings.library_root / "index" / "catalog.json").is_file(),
|
|
}
|
|
|
|
|
|
@app.get("/v1/config")
|
|
async def config() -> dict[str, Any]:
|
|
providers = []
|
|
for provider in settings.providers:
|
|
if not provider.configured:
|
|
continue
|
|
providers.append({
|
|
"id": provider.id,
|
|
"label": provider.label,
|
|
"models": [
|
|
{
|
|
"id": model.id,
|
|
"vision": model.vision,
|
|
"strict_tool_schema": model.strict_tool_schema,
|
|
}
|
|
for model in provider.models
|
|
],
|
|
})
|
|
return {
|
|
"default_provider": settings.default_provider_id,
|
|
"default_model": settings.llm_model,
|
|
"providers": providers,
|
|
"model": settings.llm_model,
|
|
"configured": settings.llm_configured,
|
|
"library_samples": library.count(),
|
|
"max_repair_attempts": settings.max_repair_attempts,
|
|
}
|
|
|
|
|
|
@app.post("/v1/chat/stream")
|
|
async def chat_stream(payload: ChatRequest) -> StreamingResponse:
|
|
return StreamingResponse(
|
|
agent.stream(payload.messages, payload.conversation_id, payload.selected_task_id, payload.provider_id, payload.model_id, payload.viewer_context),
|
|
media_type="text/event-stream",
|
|
headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
|
|
)
|
|
|
|
|
|
@app.get("/v1/conversations/{conversation_id}")
|
|
async def read_conversation(conversation_id: str) -> JSONResponse:
|
|
try:
|
|
record = store.read_conversation(safe_conversation_id(conversation_id))
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
if record is None:
|
|
raise HTTPException(status_code=404, detail="Conversation not found")
|
|
return JSONResponse(record)
|
|
|
|
|
|
@app.post("/v1/conversations")
|
|
async def create_conversation() -> JSONResponse:
|
|
return JSONResponse(store.ensure_conversation(None))
|
|
|
|
|
|
@app.patch("/v1/conversations/{conversation_id}")
|
|
async def patch_conversation(conversation_id: str, payload: ConversationPatch) -> JSONResponse:
|
|
try:
|
|
record = store.ensure_conversation(safe_conversation_id(conversation_id), payload.current_task_id)
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
return JSONResponse(record)
|
|
|
|
|
|
@app.post("/v1/conversations/{conversation_id}/attachments")
|
|
async def upload_conversation_attachment(
|
|
conversation_id: str,
|
|
file: UploadFile = File(...),
|
|
) -> JSONResponse:
|
|
data = await file.read()
|
|
filename = file.filename or "attachment"
|
|
try:
|
|
conversation = safe_conversation_id(conversation_id)
|
|
if store.read_conversation(conversation) is None:
|
|
raise HTTPException(status_code=404, detail="Conversation not found")
|
|
kind = classify_upload(filename, file.content_type or "", len(data))
|
|
relative_path, _ = store.write_conversation_upload(conversation, filename, data)
|
|
extracted_path = ""
|
|
if kind == "document":
|
|
extracted_path = relative_path + ".txt"
|
|
extracted = extract_document_text(data)
|
|
store.conversation_attachment_path(conversation, extracted_path).write_text(extracted, encoding="utf-8")
|
|
record = attachment_record(conversation, filename, file.content_type or "", relative_path, data, kind, extracted_path)
|
|
store.add_conversation_attachment(conversation, record)
|
|
return JSONResponse(record)
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
|
|
|
|
@app.get("/v1/tasks/{task_id}")
|
|
async def read_task(task_id: str) -> JSONResponse:
|
|
try:
|
|
task = store.read_task(safe_task_id(task_id))
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
if task is None:
|
|
raise HTTPException(status_code=404, detail="Task not found")
|
|
return JSONResponse(task)
|
|
|
|
|
|
@app.get("/v1/tasks/{task_id}/artifacts/{artifact_path:path}")
|
|
async def read_artifact(task_id: str, artifact_path: str) -> StreamingResponse:
|
|
from fastapi.responses import FileResponse
|
|
|
|
try:
|
|
safe_id = safe_task_id(task_id)
|
|
path = store.artifact_path(safe_id, artifact_path)
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
if not path.is_file():
|
|
raise HTTPException(status_code=404, detail="Artifact not found")
|
|
return FileResponse(path, filename=path.name)
|
|
|
|
|
|
@app.get("/v1/tasks/{task_id}/parameters")
|
|
async def read_parameters(task_id: str) -> JSONResponse:
|
|
try:
|
|
safe_id = safe_task_id(task_id)
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
task = store.read_task(safe_id)
|
|
revision_id = str((task or {}).get("current_revision") or "")
|
|
revision = next((item for item in (task or {}).get("revisions", []) if item.get("revision_id") == revision_id), None)
|
|
relative = str((revision or {}).get("parameters_path") or "")
|
|
if not relative:
|
|
raise HTTPException(status_code=404, detail="No editable parameters exist for this task")
|
|
path = store.artifact_path(safe_id, relative)
|
|
if not path.is_file():
|
|
raise HTTPException(status_code=404, detail="Parameter contract not found")
|
|
return JSONResponse({"task_id": safe_id, "revision_id": revision_id, **json.loads(path.read_text(encoding="utf-8"))})
|
|
|
|
|
|
@app.get("/v1/tasks/{task_id}/quality")
|
|
async def read_quality(task_id: str) -> JSONResponse:
|
|
try:
|
|
safe_id = safe_task_id(task_id)
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
task = store.read_task(safe_id)
|
|
revision_id = str((task or {}).get("current_revision") or "")
|
|
revisions = (task or {}).get("revisions", [])
|
|
revision = next((item for item in revisions if item.get("revision_id") == revision_id), None)
|
|
if revisions and revisions[-1].get("revision_id") != revision_id:
|
|
revision = revisions[-1]
|
|
revision_id = str(revision.get("revision_id") or "")
|
|
payload: dict[str, Any] = {
|
|
"task_id": safe_id,
|
|
"revision_id": revision_id,
|
|
"quality_status": (revision or {}).get("quality_status", ""),
|
|
"snapshot_status": (revision or {}).get("snapshot_status", "unavailable"),
|
|
"snapshot_paths": (revision or {}).get("snapshot_paths", []),
|
|
"assumptions": (revision or {}).get("generation_assumptions", []),
|
|
"verification_summary": (revision or {}).get("verification_summary", {}),
|
|
}
|
|
relative = str((revision or {}).get("quality_path") or "")
|
|
if relative:
|
|
path = store.artifact_path(safe_id, relative)
|
|
if path.is_file():
|
|
payload["quality"] = json.loads(path.read_text(encoding="utf-8"))
|
|
if not revision:
|
|
raise HTTPException(status_code=404, detail="Task has no revision")
|
|
return JSONResponse(payload)
|
|
|
|
|
|
@app.post("/v1/tasks/{task_id}/parameters")
|
|
async def update_parameters(task_id: str, payload: ParameterUpdate) -> JSONResponse:
|
|
try:
|
|
safe_id = safe_task_id(task_id)
|
|
task = store.read_task(safe_id)
|
|
current_revision_id = str((task or {}).get("current_revision") or "")
|
|
current_path = store.current_cdsl_path(safe_id)
|
|
if not task or not current_path or not current_revision_id:
|
|
raise ValueError("Task has no successful CDSL revision")
|
|
updated, _ = apply_parameter_updates(json.loads(current_path.read_text(encoding="utf-8")), payload.values)
|
|
result = build_revision(
|
|
settings=settings,
|
|
store=store,
|
|
task_id=safe_id,
|
|
request=f"Parameter update: {', '.join(payload.values)}",
|
|
cdsl=updated,
|
|
reference_ids=[],
|
|
summary="Updated CDSL parameters",
|
|
parent_revision_id=current_revision_id,
|
|
operation={"type": "parameter_update", "values": payload.values},
|
|
part_skills=None,
|
|
generation_assumptions=[],
|
|
)
|
|
return JSONResponse(result)
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|
|
|
|
|
|
@app.post("/v1/tasks/{task_id}/modify")
|
|
async def modify_task(task_id: str, payload: ModifyRequest) -> JSONResponse:
|
|
from app.services.editing import apply_direct_edit
|
|
|
|
try:
|
|
result = apply_direct_edit(settings, store, safe_task_id(task_id), payload.operation, payload.selection, payload.parameters)
|
|
return JSONResponse(result)
|
|
except ValueError as error:
|
|
raise HTTPException(status_code=400, detail=str(error)) from error
|