241 lines
8.2 KiB
Python
241 lines
8.2 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
import re
|
|
from datetime import datetime
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, status
|
|
from sqlmodel import Session, select
|
|
|
|
from app.api.deps import get_board_or_404, require_admin_auth
|
|
from app.core.auth import AuthContext
|
|
from app.db.session import get_session
|
|
from app.integrations.openclaw_gateway import GatewayConfig as GatewayClientConfig
|
|
from app.integrations.openclaw_gateway import OpenClawGatewayError, ensure_session, get_chat_history, send_message
|
|
from app.models.board_onboarding import BoardOnboardingSession
|
|
from app.models.boards import Board
|
|
from app.models.gateways import Gateway
|
|
from app.schemas.board_onboarding import (
|
|
BoardOnboardingAnswer,
|
|
BoardOnboardingConfirm,
|
|
BoardOnboardingRead,
|
|
BoardOnboardingStart,
|
|
)
|
|
from app.schemas.boards import BoardRead
|
|
|
|
router = APIRouter(prefix="/boards/{board_id}/onboarding", tags=["board-onboarding"])
|
|
|
|
SESSION_PREFIX = "agent:main:onboarding:"
|
|
|
|
|
|
def _extract_json(text: str) -> dict[str, object] | None:
|
|
try:
|
|
return json.loads(text.strip())
|
|
except Exception:
|
|
pass
|
|
match = re.search(r"```(?:json)?\s*([\s\S]*?)```", text)
|
|
if match:
|
|
try:
|
|
return json.loads(match.group(1).strip())
|
|
except Exception:
|
|
pass
|
|
first = text.find("{")
|
|
last = text.rfind("}")
|
|
if first != -1 and last > first:
|
|
try:
|
|
return json.loads(text[first : last + 1])
|
|
except Exception:
|
|
return None
|
|
return None
|
|
|
|
|
|
def _extract_text(content: object) -> str | None:
|
|
if isinstance(content, str):
|
|
return content
|
|
if isinstance(content, list):
|
|
for entry in content:
|
|
if isinstance(entry, dict) and entry.get("type") == "text":
|
|
text = entry.get("text")
|
|
if isinstance(text, str):
|
|
return text
|
|
if isinstance(content, dict):
|
|
text = content.get("text")
|
|
if isinstance(text, str):
|
|
return text
|
|
return None
|
|
|
|
|
|
def _get_assistant_messages(history: object) -> list[str]:
|
|
messages: list[str] = []
|
|
if isinstance(history, dict):
|
|
history = history.get("messages")
|
|
if not isinstance(history, list):
|
|
return messages
|
|
for msg in history:
|
|
if not isinstance(msg, dict):
|
|
continue
|
|
if msg.get("role") != "assistant":
|
|
continue
|
|
text = _extract_text(msg.get("content"))
|
|
if text:
|
|
messages.append(text)
|
|
return messages
|
|
|
|
|
|
def _gateway_config(session: Session, board: Board) -> GatewayClientConfig:
|
|
if not board.gateway_id:
|
|
raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
|
|
gateway = session.get(Gateway, board.gateway_id)
|
|
if gateway is None or not gateway.url:
|
|
raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
|
|
return GatewayClientConfig(url=gateway.url, token=gateway.token)
|
|
|
|
|
|
def _session_key(board: Board) -> str:
|
|
return f"{SESSION_PREFIX}{board.id}"
|
|
|
|
|
|
@router.get("", response_model=BoardOnboardingRead)
|
|
def get_onboarding(
|
|
board: Board = Depends(get_board_or_404),
|
|
session: Session = Depends(get_session),
|
|
auth: AuthContext = Depends(require_admin_auth),
|
|
) -> BoardOnboardingSession:
|
|
onboarding = session.exec(
|
|
select(BoardOnboardingSession)
|
|
.where(BoardOnboardingSession.board_id == board.id)
|
|
.order_by(BoardOnboardingSession.created_at.desc())
|
|
).first()
|
|
if onboarding is None:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
|
return onboarding
|
|
|
|
|
|
@router.post("/start", response_model=BoardOnboardingRead)
|
|
async def start_onboarding(
|
|
payload: BoardOnboardingStart,
|
|
board: Board = Depends(get_board_or_404),
|
|
session: Session = Depends(get_session),
|
|
auth: AuthContext = Depends(require_admin_auth),
|
|
) -> BoardOnboardingSession:
|
|
onboarding = session.exec(
|
|
select(BoardOnboardingSession)
|
|
.where(BoardOnboardingSession.board_id == board.id)
|
|
.where(BoardOnboardingSession.status == "active")
|
|
).first()
|
|
if onboarding:
|
|
return onboarding
|
|
|
|
config = _gateway_config(session, board)
|
|
session_key = _session_key(board)
|
|
prompt = (
|
|
"BOARD ONBOARDING REQUEST\n\n"
|
|
f"Board Name: {board.name}\n"
|
|
"You are the lead agent. Ask the user 3-6 focused questions to clarify their goal.\n"
|
|
"Return questions as JSON: {\"question\": \"...\", \"options\": [...]}.\n"
|
|
"When you have enough info, return JSON: {\"status\": \"complete\", \"board_type\": \"goal\"|\"general\", "
|
|
"\"objective\": \"...\", \"success_metrics\": {...}, \"target_date\": \"YYYY-MM-DD\"}."
|
|
)
|
|
|
|
try:
|
|
await ensure_session(session_key, config=config, label=f"Onboarding {board.name}")
|
|
await send_message(prompt, session_key=session_key, config=config, deliver=True)
|
|
except OpenClawGatewayError as exc:
|
|
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
|
|
|
|
onboarding = BoardOnboardingSession(
|
|
board_id=board.id,
|
|
session_key=session_key,
|
|
status="active",
|
|
messages=[{"role": "user", "content": prompt, "timestamp": datetime.utcnow().isoformat()}],
|
|
)
|
|
session.add(onboarding)
|
|
session.commit()
|
|
session.refresh(onboarding)
|
|
return onboarding
|
|
|
|
|
|
@router.post("/answer", response_model=BoardOnboardingRead)
|
|
async def answer_onboarding(
|
|
payload: BoardOnboardingAnswer,
|
|
board: Board = Depends(get_board_or_404),
|
|
session: Session = Depends(get_session),
|
|
auth: AuthContext = Depends(require_admin_auth),
|
|
) -> BoardOnboardingSession:
|
|
onboarding = session.exec(
|
|
select(BoardOnboardingSession)
|
|
.where(BoardOnboardingSession.board_id == board.id)
|
|
.order_by(BoardOnboardingSession.created_at.desc())
|
|
).first()
|
|
if onboarding is None:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
config = _gateway_config(session, board)
|
|
answer_text = payload.answer
|
|
if payload.other_text:
|
|
answer_text = f"{payload.answer}: {payload.other_text}"
|
|
|
|
messages = onboarding.messages or []
|
|
messages.append(
|
|
{"role": "user", "content": answer_text, "timestamp": datetime.utcnow().isoformat()}
|
|
)
|
|
|
|
try:
|
|
await ensure_session(onboarding.session_key, config=config, label=f"Onboarding {board.name}")
|
|
await send_message(
|
|
answer_text, session_key=onboarding.session_key, config=config, deliver=True
|
|
)
|
|
history = await get_chat_history(onboarding.session_key, config=config)
|
|
except OpenClawGatewayError as exc:
|
|
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
|
|
|
|
assistant_messages = _get_assistant_messages(history)
|
|
if assistant_messages:
|
|
last = assistant_messages[-1]
|
|
messages.append(
|
|
{"role": "assistant", "content": last, "timestamp": datetime.utcnow().isoformat()}
|
|
)
|
|
parsed = _extract_json(last)
|
|
if parsed and parsed.get("status") == "complete":
|
|
onboarding.draft_goal = parsed
|
|
onboarding.status = "completed"
|
|
|
|
onboarding.messages = messages
|
|
onboarding.updated_at = datetime.utcnow()
|
|
session.add(onboarding)
|
|
session.commit()
|
|
session.refresh(onboarding)
|
|
return onboarding
|
|
|
|
|
|
@router.post("/confirm", response_model=BoardRead)
|
|
def confirm_onboarding(
|
|
payload: BoardOnboardingConfirm,
|
|
board: Board = Depends(get_board_or_404),
|
|
session: Session = Depends(get_session),
|
|
auth: AuthContext = Depends(require_admin_auth),
|
|
) -> Board:
|
|
onboarding = session.exec(
|
|
select(BoardOnboardingSession)
|
|
.where(BoardOnboardingSession.board_id == board.id)
|
|
.order_by(BoardOnboardingSession.created_at.desc())
|
|
).first()
|
|
if onboarding is None:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
board.board_type = payload.board_type
|
|
board.objective = payload.objective
|
|
board.success_metrics = payload.success_metrics
|
|
board.target_date = payload.target_date
|
|
board.goal_confirmed = True
|
|
board.goal_source = "lead_agent_onboarding"
|
|
|
|
onboarding.status = "confirmed"
|
|
onboarding.updated_at = datetime.utcnow()
|
|
|
|
session.add(board)
|
|
session.add(onboarding)
|
|
session.commit()
|
|
session.refresh(board)
|
|
return board
|