"""Chat endpoint — POST /api/chat. Grounded on the latest strategic log, current market quotes, and thesis-filtered headlines. Ephemeral: the conversation lives in the client; this endpoint just records each call's cost in `ai_calls`. """ from __future__ import annotations from collections import defaultdict from datetime import timedelta import httpx from fastapi import APIRouter, Depends, HTTPException from pydantic import BaseModel, Field from sqlalchemy import desc, func, select from sqlalchemy.ext.asyncio import AsyncSession from app.auth import require_token, maybe_current_user, CurrentUser from app.config import get_settings from app.db import get_session, utcnow from app.jobs._market_context import REFERENCE_LINE from app.models import AICall, Headline, Quote, StrategicLog from app.routers.api import _md_to_html from app.services.i18n import respond_in_clause from app.services.llm_prompts import build_chat_system_prompt from app.services.openrouter import call_llm, month_start from app.services.output_review import review_read from app.logging import get_logger log = get_logger("chat") router = APIRouter(dependencies=[Depends(require_token)]) # --------------------------------------------------------------------------- # Pydantic models # --------------------------------------------------------------------------- class ChatMessage(BaseModel): role: str = Field(pattern="^(user|assistant)$") content: str class ChatRequest(BaseModel): messages: list[ChatMessage] # --------------------------------------------------------------------------- # Private helpers # --------------------------------------------------------------------------- THESIS_KEYWORDS_FALLBACK = [ "hormuz", "iran", "opec", "brent", "wti", "crude", "oil", "china", "taiwan", "yuan", "fed", "inflation", "cpi", "yield", "gold", "dollar", "yen", "saudi", "russia", "ukraine", "israel", "nato", "defence", "defense", ] async def _latest_quotes_by_group_chat(session: AsyncSession) -> dict[str, list[dict]]: sub = ( select(Quote.group_name, Quote.symbol, func.max(Quote.fetched_at).label("mx")) .group_by(Quote.group_name, Quote.symbol) .subquery() ) rows = (await session.execute( select(Quote).join( sub, (Quote.group_name == sub.c.group_name) & (Quote.symbol == sub.c.symbol) & (Quote.fetched_at == sub.c.mx), ).order_by(Quote.group_name, Quote.symbol) )).scalars().all() by_group: dict[str, list[dict]] = defaultdict(list) for q in rows: by_group[q.group_name].append({ "symbol": q.symbol, "label": q.label, "price": q.price, "currency": q.currency, "as_of": q.as_of, "changes": q.changes, }) return by_group async def _thesis_headlines_for_chat(session: AsyncSession, limit: int = 50) -> list[dict]: cutoff = utcnow() - timedelta(hours=24) rows = (await session.execute( select(Headline) .where(Headline.published_at >= cutoff) .order_by(desc(Headline.published_at)) .limit(300) )).scalars().all() out = [] for h in rows: if any(kw in h.title.lower() for kw in THESIS_KEYWORDS_FALLBACK): out.append({"source": h.source, "title": h.title}) if len(out) >= limit: break return out async def _month_spend(session: AsyncSession) -> float: total = (await session.execute( select(func.coalesce(func.sum(AICall.cost_usd), 0.0)) .where(AICall.called_at >= month_start()) )).scalar() return float(total or 0.0) # --------------------------------------------------------------------------- # Route # --------------------------------------------------------------------------- @router.post("/chat") async def chat( body: ChatRequest, session: AsyncSession = Depends(get_session), principal: CurrentUser | None = Depends(maybe_current_user), ): """Answer one user turn given the conversation so far. Grounded on the latest strategic log + market data + thesis-filtered headlines. Ephemeral — the conversation lives entirely in the client; the endpoint just records each call's cost in `ai_calls`.""" # Paid-only feature. Free users get the static log but not the # interactive chat (see /pricing). from app.services.access import is_paid_active if not is_paid_active(principal): raise HTTPException( status_code=402, detail={"code": "paid_required", "message": "Follow-up chat is a paid-tier feature."}, ) s = get_settings() if not s.OPENROUTER_API_KEY: raise HTTPException(status_code=503, detail="OPENROUTER_API_KEY not set") # Monthly cost cap — same one the log job respects. spent = await _month_spend(session) if spent >= s.OPENROUTER_MONTHLY_CAP_USD: raise HTTPException( status_code=429, detail=f"Monthly OpenRouter cap reached (${spent:.2f})", ) # Trim runaway conversations: keep last 20 turns. history = body.messages[-20:] if not history or history[-1].role != "user": raise HTTPException(status_code=400, detail="Last message must be user") # Gather grounding context. log_row = (await session.execute( select(StrategicLog).order_by(desc(StrategicLog.generated_at)).limit(1) )).scalar_one_or_none() quotes = await _latest_quotes_by_group_chat(session) headlines = await _thesis_headlines_for_chat(session) system_prompt = build_chat_system_prompt( s.CASSANDRA_TONE, s.CASSANDRA_ANALYSIS, log_content=log_row.content if log_row else None, log_generated_at=log_row.generated_at if log_row else None, quotes_by_group=quotes, headlines=headlines, reference_line=REFERENCE_LINE, ) # Respect the user's interface language preference: append a single # localized "respond in" nudge so the assistant answers in IT when # the user has lang=it. The prompt + history (which includes the # user's own question, often in their language) are usually enough, # but the nudge guarantees the first reply lands correctly. user_lang = principal.user.lang if principal and principal.user else "en" system_prompt = system_prompt + respond_in_clause(user_lang) msgs = [{"role": "system", "content": system_prompt}] for m in history: msgs.append({"role": m.role, "content": m.content}) try: async with httpx.AsyncClient(follow_redirects=True) as client: result = await call_llm(client, msgs) # Reviewer gate. The chat turn could solicit advice with a # leading question; the generator's system prompt forbids it, # but the reviewer is the enforcement layer. ~1-2 s extra # latency per turn on top of the generation call. verdict = await review_read(client, result.content) except Exception as e: session.add(AICall( model=s.OPENROUTER_MODEL, status="error", error=str(e)[:500], )) await session.commit() raise HTTPException(status_code=502, detail=f"OpenRouter error: {e}") full_cost = (result.cost_usd or 0.0) + (verdict.cost_usd or 0.0) if not verdict.clean: # Rejected reply. Record the cost and surface a generic refusal # the user can retry, rather than letting potentially non-compliant # text reach them. session.add(AICall( model=result.model, prompt_tokens=result.prompt_tokens, completion_tokens=result.completion_tokens, cost_usd=full_cost, status="leaked", error=f"reviewer: {verdict.reason}", )) await session.commit() log.warning("chat.reviewer_rejected", reason=verdict.reason, preview=result.content[:120]) refusal = ( "I can't generate that reply — it would have crossed into " "investment advice or specific recommendations, which I'm " "not licensed to give. Try rephrasing as a question about " "what the data means rather than what to do." ) return { "role": "assistant", "content": refusal, "content_html": _md_to_html(refusal), "prompt_tokens": result.prompt_tokens, "completion_tokens": result.completion_tokens, } session.add(AICall( model=result.model, prompt_tokens=result.prompt_tokens, completion_tokens=result.completion_tokens, cost_usd=full_cost, status="ok", )) await session.commit() return { "role": "assistant", "content": result.content, "content_html": _md_to_html(result.content), "prompt_tokens": result.prompt_tokens, "completion_tokens": result.completion_tokens, }