fix: validate retrieval-only chat questions before dispatch

backend/app/api/routes/chat.py

@@ -26,9 +26,6 @@ def chat(payload: ChatRequest, db: Session = Depends(get_db)) -> ChatResponse:
             "因此系统仅返回可追溯证据，不生成或改写答案。"
         ),
         status="retrieval_only",
-        sources=[
-            {"title": hit.title, "source_url": hit.source_url}
-            for hit in result.results
-        ],
+        sources=[{"title": hit.title, "source_url": hit.source_url} for hit in result.results],
         retrieval_run_id=result.run_id,
     )

backend/app/schemas/chat.py

@@ -1,11 +1,14 @@
 from typing import Literal
 from uuid import UUID
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
+
+from app.schemas.catalog import Input
+from app.schemas.retrieval import QueryText
 
 
-class ChatRequest(BaseModel):
-    question: str = Field(min_length=1, max_length=2000)
+class ChatRequest(Input):
+    question: QueryText
 
 
 class SourcePreview(BaseModel):

backend/app/schemas/retrieval.py

@@ -1,14 +1,16 @@
 from datetime import datetime
-from typing import Literal
+from typing import Annotated, Literal
 from uuid import UUID
 
 from pydantic import BaseModel, Field
 
 from app.schemas.catalog import Category, Input
 
+QueryText = Annotated[str, Field(min_length=1, max_length=500)]
+
 
 class RetrievalRequest(Input):
-    query: str = Field(min_length=1, max_length=500)
+    query: QueryText
     mode: Literal["keyword"] = "keyword"
     top_k: int = Field(default=5, ge=1, le=20)
     category: Category | None = None

backend/tests/test_chat.py

@@ -0,0 +1,161 @@
+"""Retrieval-only chat integration; synthetic evidence, never a generation call."""
+
+import copy
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import func, select, text
+from sqlalchemy.orm import Session
+from test_catalog import document, source
+from test_retrieval import add_item
+from test_runtime import server
+
+from app.models.rag import RagContext
+from app.models.retrieval import RetrievalRun
+from app.services import retrieval
+
+
+def test_overlong_chat_question_is_rejected_at_the_http_boundary(client):
+    with TestClient(
+        client.app, base_url="https://testserver", raise_server_exceptions=False
+    ) as public:
+        response = public.post("/api/chat", json={"question": "q" * 501})
+    assert response.status_code == 422, response.text
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {},
+        {"question": ""},
+        {"question": " \t\n "},
+        {"question": None},
+        {"question": 123},
+        {"question": "q" * 2000},
+        {"question": "q" * 2001},
+        {"question": "alpha", "model": "not-accepted"},
+        {"question": "alpha", "messages": []},
+    ],
+)
+def test_invalid_chat_input_creates_no_retrieval_or_context(client, migrated_database, payload):
+    response = client.post("/api/chat", json=payload)
+    assert response.status_code == 422, response.text
+    assert all("input" not in error for error in response.json()["detail"])
+    with Session(migrated_database) as db:
+        assert db.scalar(select(func.count()).select_from(RetrievalRun)) == 0
+        assert db.scalar(select(func.count()).select_from(RagContext)) == 0
+
+
+def test_chat_query_boundary_normalization_and_public_history_permissions(client):
+    response = client.post("/api/chat", json={"question": "q" * 500})
+    assert response.status_code == 200, response.text
+    assert response.json()["status"] == "no_evidence"
+    client.cookies.clear()
+    public = client.post("/api/chat", json={"question": "  alpha  "})
+    assert public.status_code == 200
+    assert public.json()["status"] == "no_evidence" and public.json()["sources"] == []
+    assert client.get(f"/api/retrieval/runs/{public.json()['retrieval_run_id']}").status_code == 401
+
+
+def test_chat_sources_match_audited_snapshot_and_history_stays_immutable(client, migrated_database):
+    approved = add_item(client, title="verified alpha", content="alpha synthetic evidence")
+    add_item(client, status="pending", title="pending alpha", content="alpha unreviewed")
+    add_item(client, status="rejected", title="rejected alpha", content="alpha rejected")
+    deleted = add_item(client, title="deleted alpha", content="alpha deleted")
+    assert (
+        client.delete(
+            f"/api/knowledge/{deleted['id']}?expected_version={deleted['version']}"
+        ).status_code
+        == 204
+    )
+    result = client.post("/api/chat", json={"question": "  alpha  "}).json()
+    assert result["status"] == "retrieval_only" and "不生成" in result["answer"]
+    history = client.get(f"/api/retrieval/runs/{result['retrieval_run_id']}").json()
+    assert history["query"] == "alpha" and history["mode"] == "keyword"
+    assert [h["knowledge_id"] for h in history["results"]] == [approved["id"]]
+    assert result["sources"] == [
+        {"title": h["title"], "source_url": h["source_url"]} for h in history["results"]
+    ]
+    saved = copy.deepcopy(history)
+    assert (
+        client.patch(
+            f"/api/knowledge/{approved['id']}",
+            json={"expected_version": approved["version"], "content": "revised alpha"},
+        ).status_code
+        == 200
+    )
+    assert client.post("/api/chat", json={"question": "alpha"}).json()["status"] == "no_evidence"
+    assert client.get(f"/api/retrieval/runs/{history['run_id']}").json() == saved
+    assert (
+        client.post(
+            "/api/rag/contexts",
+            json={"retrieval_run_id": history["run_id"], "completion": {"model": "contract-model"}},
+        ).status_code
+        == 422
+    )
+    with Session(migrated_database) as db:
+        assert db.scalar(select(func.count()).select_from(RagContext)) == 0
+
+
+@pytest.mark.parametrize("change", ["source", "document"])
+def test_chat_cannot_reuse_evidence_after_catalog_revision(client, change):
+    src = source(client)
+    doc = document(client, src["id"])
+    add_item(client, document_id=doc["id"], content="alpha synthetic catalog evidence")
+    assert client.post("/api/chat", json={"question": "alpha"}).json()["status"] == "retrieval_only"
+    path, version, fields = (
+        (f"sources/{src['id']}", src["version"], {"source_url": "https://example.com/new"})
+        if change == "source"
+        else (f"documents/{doc['id']}", doc["version"], {"content": "revised synthetic document"})
+    )
+    assert (
+        client.patch("/api/" + path, json={"expected_version": version, **fields}).status_code
+        == 200
+    )
+    result = client.post("/api/chat", json={"question": "alpha"}).json()
+    assert result["status"] == "no_evidence" and result["sources"] == []
+
+
+def test_chat_capacity_failure_is_not_a_successful_empty_answer(
+    client, migrated_database, monkeypatch
+):
+    add_item(client, content="alpha synthetic capacity evidence")
+    monkeypatch.setattr(retrieval, "MAX_ITEMS", 0)
+    response = client.post("/api/chat", json={"question": "alpha"})
+    assert response.status_code == 503 and "sources" not in response.json()
+    with Session(migrated_database) as db:
+        assert db.scalar(select(func.count()).select_from(RetrievalRun)) == 0
+
+
+def test_chat_failed_history_insert_does_not_leave_partial_rows(client, migrated_database):
+    with migrated_database.begin() as db:
+        db.execute(
+            text("ALTER TABLE retrieval_runs ADD CONSTRAINT reject_chat_run CHECK(false) NOT VALID")
+        )
+    assert client.post("/api/chat", json={"question": "alpha"}).status_code == 409
+    with Session(migrated_database) as db:
+        assert db.scalar(select(func.count()).select_from(RetrievalRun)) == 0
+
+
+def test_chat_retrieval_history_survives_real_http_restart(migrated_database):
+    with server(migrated_database) as client:
+        assert client.post("/api/chat", json={"question": "q" * 501}).status_code == 422
+        item = add_item(client, content="alpha real HTTP synthetic evidence")
+        response = client.post("/api/chat", json={"question": " alpha "})
+        assert response.status_code == 200
+        result = response.json()
+        history = client.get(f"/api/retrieval/runs/{result['retrieval_run_id']}").json()
+        assert history["results"][0]["knowledge_id"] == item["id"]
+        assert history["query"] == "alpha"
+    with server(migrated_database) as client:
+        assert client.get(f"/api/retrieval/runs/{result['retrieval_run_id']}").json() == history
+        exported = client.post(
+            "/api/retrieval/exports",
+            json={"run_ids": [result["retrieval_run_id"]], "include_contexts": True},
+        )
+        assert exported.status_code == 200
+        client.cookies.clear()
+        assert (
+            client.post("/api/chat", json={"question": "alpha"}).json()["status"]
+            == "retrieval_only"
+        )