浅念
143 lines
5.2 KiB
Python
143 lines
5.2 KiB
Python
"""REST shell for the HESU app (non-streaming, JSON-in/JSON-out).
|
|
|
|
These routes wrap `ConversationManager`, shared with the existing `/ws/chat`
|
|
widget path. The app uses HTTP because it lacks a WebSocket client and is fine
|
|
with a 3-8s "AI is typing" affordance covering the round trip.
|
|
|
|
Red lines (see spec):
|
|
- WS path (`app/api/routes/chat.py`) shares `ConversationManager` with these
|
|
routes; both paths stay drift-free.
|
|
- `context` seeding is conditional + whitelist (handled in
|
|
`ConversationManager.create_conversation`).
|
|
- The message route consumes `stream_process_message`; lead email is
|
|
triggered inside `ConversationManager` when contact info is detected
|
|
(contact-driven-lead-email plan).
|
|
"""
|
|
from fastapi import APIRouter, HTTPException, Request
|
|
from pydantic import BaseModel
|
|
from sqlalchemy import select
|
|
|
|
from app.main import async_session
|
|
from app.models.database import ConversationSource, ConversationStatus, Message
|
|
from app.services.conversation import ConversationManager
|
|
from app.services.rate_limit import check as rate_check
|
|
|
|
router = APIRouter(prefix="/api/chat", tags=["chat-rest"])
|
|
|
|
|
|
class SessionRequest(BaseModel):
|
|
session_id: str | None = None
|
|
context: dict | None = None
|
|
client_info: dict | None = None
|
|
|
|
|
|
@router.post("/session")
|
|
async def chat_session(req: SessionRequest):
|
|
"""Resume an active conversation by session_id, or create a new app one.
|
|
|
|
`context` flows into `create_conversation` where it is whitelisted into
|
|
`raw_info` (only when non-None). `client_info` is stored for analytics only
|
|
(ip/ua/device-id/lang) and never fed to the AI prompt.
|
|
"""
|
|
async with async_session() as db:
|
|
manager = ConversationManager(db)
|
|
if req.session_id:
|
|
conv = await manager.get_by_session(req.session_id)
|
|
if conv and conv.status == ConversationStatus.active:
|
|
return {
|
|
"session_id": conv.session_id,
|
|
"is_new": False,
|
|
"ended": False,
|
|
}
|
|
conv = await manager.create_conversation(
|
|
source=ConversationSource.app,
|
|
client_info=req.client_info,
|
|
context=req.context,
|
|
)
|
|
return {
|
|
"session_id": conv.session_id,
|
|
"is_new": True,
|
|
"ended": False,
|
|
}
|
|
|
|
|
|
@router.get("/{session_id}/messages")
|
|
async def chat_history(session_id: str):
|
|
"""Public history endpoint for session replay. App-source only, to narrow
|
|
the read surface; an unknown or non-app session yields 404.
|
|
"""
|
|
async with async_session() as db:
|
|
manager = ConversationManager(db)
|
|
conv = await manager.get_by_session(session_id)
|
|
if not conv or conv.source != ConversationSource.app:
|
|
raise HTTPException(status_code=404, detail="session not found")
|
|
result = await db.execute(
|
|
select(Message)
|
|
.where(Message.conversation_id == conv.id)
|
|
.order_by(Message.created_at)
|
|
)
|
|
msgs = result.scalars().all()
|
|
return [
|
|
{
|
|
"role": m.role.value,
|
|
"content": m.content,
|
|
"created_at": m.created_at.isoformat(),
|
|
}
|
|
for m in msgs
|
|
]
|
|
|
|
|
|
class MessageRequest(BaseModel):
|
|
session_id: str
|
|
content: str
|
|
|
|
|
|
@router.post("/message")
|
|
async def chat_message(req: MessageRequest, request: Request):
|
|
"""Process one app turn: stream-collect the AI reply, then evaluate.
|
|
|
|
🔴 Consumes `stream_process_message` so the REST path shares one code
|
|
path with the WS widget and never drifts. Lead email is triggered inside
|
|
`ConversationManager` when contact info is detected
|
|
(contact-driven-lead-email plan) — this route carries no email logic.
|
|
|
|
A light in-memory rate limit (per ip + X-Device-Id, 30/h) guards GLM
|
|
spend; only this route is throttled.
|
|
"""
|
|
ip = request.client.host if request.client else ""
|
|
dev = request.headers.get("X-Device-Id", "")
|
|
if not rate_check(ip, dev):
|
|
raise HTTPException(status_code=429, detail="rate limit exceeded")
|
|
|
|
async with async_session() as db:
|
|
manager = ConversationManager(db)
|
|
conv = await manager.get_by_session(req.session_id)
|
|
if not conv:
|
|
raise HTTPException(status_code=404, detail="session not found")
|
|
if conv.status != ConversationStatus.active:
|
|
raise HTTPException(status_code=409, detail="conversation ended")
|
|
|
|
reply_parts: list[str] = []
|
|
ended = False
|
|
intent_level = "pending"
|
|
async for event in manager.stream_process_message(
|
|
req.session_id, req.content
|
|
):
|
|
t = event.get("type")
|
|
if t == "stream_chunk":
|
|
reply_parts.append(event.get("content", ""))
|
|
elif t == "evaluated":
|
|
ended = bool(event.get("ended"))
|
|
intent_level = event.get("intent_level", "pending")
|
|
elif t == "error":
|
|
msg = event.get("message", "error")
|
|
raise HTTPException(
|
|
status_code=409 if "ended" in msg else 404, detail=msg
|
|
)
|
|
|
|
return {
|
|
"reply": "".join(reply_parts),
|
|
"ended": ended,
|
|
"intent_level": intent_level,
|
|
}
|