sync update from LAN repo (source dhk-1 @ 3b1ec5b4)

This commit is contained in:
gozeros committed 2026-11-05 10:56:34 +08:00
1 parent da6521b6cb
commit 264e2200d6
995 files changed
+148105 -13399

No files matched your search

@@ -20,34 +20,37 @@ import os
import re
from collections.abc import AsyncIterator
from contextvars import ContextVar
from datetime import UTC, datetime, timedelta
from datetime import time as datetime_time
from hashlib import sha256
from time import perf_counter
from typing import Any
from datetime import UTC, datetime, timedelta, time as datetime_time
from fastapi import APIRouter, Depends, HTTPException, Query, Request
from fastapi.responses import StreamingResponse
from langchain_core.messages import HumanMessage, SystemMessage
from pydantic import BaseModel, Field
from sqlalchemy import and_, case, desc, func, not_, or_, select, text
from langchain_core.messages import HumanMessage, SystemMessage
from app.gateway.admin_query_window import (
ADMIN_QUERY_WINDOW_DAYS,
resolve_admin_query_window,
)
from app.gateway.deps import (
get_config,
get_agent_store,
get_checkpointer,
get_config,
get_current_user_from_request,
get_thread_store,
)
from app.gateway.routers.memory import _build_v1_provider, _is_v1
from deerflow.agents.memory import BuiltinFileProvider
from deerflow.config.app_config import AppConfig
from deerflow.config.paths import get_paths
from deerflow.config.system_settings import load_system_settings
from deerflow.models import create_chat_model
from deerflow.runtime import serialize_channel_values
from app.gateway.routers.memory import _build_v1_provider, _is_v1
from deerflow.persistence.engine import get_session_factory
from deerflow.persistence.admin_stats.model import AdminLeaderboardDailyStatRow
from deerflow.persistence.engine import get_session_factory
from deerflow.persistence.llm_metrics.model import LlmCallMetricRow
from deerflow.persistence.run.model import RunRow
from deerflow.persistence.scheduled_tasks.model import ScheduledTaskRunRow
@@ -55,6 +58,7 @@ from deerflow.persistence.thread_meta.model import ThreadMetaRow
from deerflow.persistence.tool_metrics.model import ToolCallMetricRow
from deerflow.persistence.types import BEIJING_TZ
from deerflow.persistence.user.model import UserRow
from deerflow.runtime import serialize_channel_values
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/api/admin/users", tags=["admin-users"])
@@ -92,6 +96,13 @@ _LEADERBOARD_LOCK_WAIT_SECONDS = max(
1,
int(os.getenv("ADMIN_LEADERBOARD_LOCK_WAIT_SECONDS", "5")),
)
# The checkpoint fallback exists for installations that predate compact run
# summaries. Keep its work deliberately small: current run summaries are the
# indexed source of truth for an administrator's recent audit view.
_ADMIN_QA_CHECKPOINT_THREAD_LIMIT = 25
_ADMIN_QA_CHECKPOINT_MESSAGE_LIMIT = 100
_ADMIN_QA_CHECKPOINT_ITEM_LIMIT = 500
_ADMIN_QA_RUN_CANDIDATE_LIMIT = 1_000
_LEADERBOARD_QUEUE_ON_REQUEST_ENABLED = os.getenv(
"ADMIN_LEADERBOARD_QUEUE_ON_REQUEST_ENABLED",
os.getenv("ADMIN_LEADERBOARD_WEB_QUEUE_ENABLED", "true"),
@@ -307,20 +318,6 @@ class AdminLeaderboardResponse(BaseModel):
trends: list[AdminLeaderboardTrendPoint] = Field(default_factory=list)
class AdminUserAnalyticsResponse(BaseModel):
range_days: int
since: str
until: str
user: AdminLeaderboardUser
overview: AdminLeaderboardOverview
skills: list[AdminLeaderboardSkill] = Field(default_factory=list)
tools: list[AdminLeaderboardSkill] = Field(default_factory=list)
models: list[AdminLeaderboardDimension] = Field(default_factory=list)
agents: list[AdminLeaderboardDimension] = Field(default_factory=list)
run_statuses: list[AdminLeaderboardDimension] = Field(default_factory=list)
trends: list[AdminLeaderboardTrendPoint] = Field(default_factory=list)
class AdminLeaderboardReportResponse(BaseModel):
report: str
generated_at: str
@@ -352,7 +349,7 @@ class AdminLeaderboardSnapshotStatusResponse(BaseModel):
class AdminLeaderboardSnapshotBackfillRequest(BaseModel):
days: int = Field(default=30, ge=1, le=365)
days: int = Field(default=30, ge=1, le=ADMIN_QUERY_WINDOW_DAYS)
since: str | None = Field(default=None, description="Inclusive range start, ISO datetime")
until: str | None = Field(default=None, description="Inclusive range end, ISO datetime")
force: bool = Field(default=False, description="Queue dates even when a ready snapshot already exists")
@@ -463,6 +460,13 @@ async def _set_analytics_read_timeout(session) -> None:
(5.6 raises "Unknown system variable" otherwise)
- PostgreSQL/openGauss: ``statement_timeout`` (milliseconds)
"""
from deerflow.persistence.gauss_mysql_compat import is_gauss_mysql_product
# Dolphin does not implement either MySQL session variable below. A failed
# SET aborts the current openGauss transaction, so skip before touching it.
if is_gauss_mysql_product():
return
conn = await session.connection()
dialect = conn.dialect
name = dialect.name
@@ -1732,7 +1736,7 @@ async def _refresh_daily_leaderboard_snapshot(
datetime.now(BEIJING_TZ).isoformat(),
(perf_counter() - snapshot_start) * 1000,
)
except asyncio.TimeoutError:
except TimeoutError:
logger.warning("Daily leaderboard snapshot timed out: %s", job_key)
await _store_daily_snapshot(
session_factory,
@@ -1838,7 +1842,7 @@ async def _load_or_schedule_daily_leaderboard(
@router.get("/leaderboard", response_model=AdminLeaderboardResponse)
async def get_user_leaderboard(
request: Request,
days: int = Query(default=30, ge=1, le=365),
days: int = Query(default=30, ge=1, le=ADMIN_QUERY_WINDOW_DAYS),
since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
exclude_user_ids: list[str] | None = Query(default=None, description="User ids excluded from this leaderboard aggregation"),
@@ -1854,7 +1858,11 @@ async def get_user_leaderboard(
raise HTTPException(status_code=503, detail="Analytics requires database persistence")
settings = load_system_settings().leaderboard
since_dt, until_dt, _range_days = _resolve_range(days, since, until)
since_dt, until_dt, _range_days = resolve_admin_query_window(
days=days,
since=since,
until=until,
)
return await _load_or_schedule_daily_leaderboard(
session_factory,
settings,
@@ -1871,7 +1879,7 @@ async def get_user_leaderboard(
@router.get("/leaderboard/snapshots", response_model=AdminLeaderboardSnapshotStatusResponse)
async def get_leaderboard_snapshot_status(
request: Request,
days: int = Query(default=30, ge=1, le=365),
days: int = Query(default=30, ge=1, le=ADMIN_QUERY_WINDOW_DAYS),
since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
) -> AdminLeaderboardSnapshotStatusResponse:
@@ -1882,7 +1890,11 @@ async def get_leaderboard_snapshot_status(
raise HTTPException(status_code=503, detail="Analytics requires database persistence")
settings = load_system_settings().leaderboard
since_dt, until_dt, _range_days = _resolve_range(days, since, until)
since_dt, until_dt, _range_days = resolve_admin_query_window(
days=days,
since=since,
until=until,
)
stat_dates = _stat_dates_for_range(since_dt, until_dt)
*_scope, settings_hash = _resolve_leaderboard_snapshot_scope(settings)
rows = await _load_daily_snapshot_rows(session_factory, stat_dates, settings_hash)
@@ -1933,7 +1945,11 @@ async def queue_leaderboard_snapshot_backfill(
raise HTTPException(status_code=503, detail="Analytics requires database persistence")
settings = load_system_settings().leaderboard
since_dt, until_dt, _range_days = _resolve_range(body.days, body.since, body.until)
since_dt, until_dt, _range_days = resolve_admin_query_window(
days=body.days,
since=body.since,
until=body.until,
)
stat_dates = _stat_dates_for_range(since_dt, until_dt)
*_scope, settings_hash = _resolve_leaderboard_snapshot_scope(settings)
queued_dates = await _queue_daily_leaderboard_snapshots(
@@ -1956,7 +1972,7 @@ async def queue_leaderboard_snapshot_backfill(
@router.post("/leaderboard/refresh-today", response_model=AdminLeaderboardResponse)
async def refresh_today_leaderboard(
request: Request,
days: int = Query(default=30, ge=1, le=365),
days: int = Query(default=30, ge=1, le=ADMIN_QUERY_WINDOW_DAYS),
since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
exclude_user_ids: list[str] | None = Query(default=None, description="User ids excluded from this leaderboard aggregation"),
@@ -1979,6 +1995,11 @@ async def refresh_today_leaderboard(
raise HTTPException(status_code=503, detail="Analytics requires database persistence")
settings = load_system_settings().leaderboard
since_dt, until_dt, _range_days = resolve_admin_query_window(
days=days,
since=since,
until=until,
)
(
excluded,
resolved_include_scheduled,
@@ -2005,7 +2026,6 @@ async def refresh_today_leaderboard(
include_failed=resolved_include_failed,
)
since_dt, until_dt, _range_days = _resolve_range(days, since, until)
return await _load_or_schedule_daily_leaderboard(
session_factory,
settings,
@@ -2072,7 +2092,7 @@ async def _build_leaderboard_report_prompt(
@router.post("/leaderboard/report", response_model=AdminLeaderboardReportResponse)
async def generate_user_leaderboard_report(
request: Request,
days: int = Query(default=30, ge=1, le=365),
days: int = Query(default=30, ge=1, le=ADMIN_QUERY_WINDOW_DAYS),
since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
limit: int = Query(default=30, ge=10, le=100),
@@ -2086,7 +2106,11 @@ async def generate_user_leaderboard_report(
raise HTTPException(status_code=503, detail="Analytics requires database persistence")
settings = load_system_settings().leaderboard
since_dt, until_dt, _range_days = _resolve_range(days, since, until)
since_dt, until_dt, _range_days = resolve_admin_query_window(
days=days,
since=since,
until=until,
)
resolved_model_name = _resolve_report_model_name(config, model_name)
cache_key = _report_cache_key(since=since_dt, until=until_dt, limit=limit, model_name=resolved_model_name, settings=settings)
cached = _cached_report(cache_key)
@@ -2128,7 +2152,7 @@ async def generate_user_leaderboard_report(
@router.post("/leaderboard/report/stream")
async def stream_user_leaderboard_report(
request: Request,
days: int = Query(default=30, ge=1, le=365),
days: int = Query(default=30, ge=1, le=ADMIN_QUERY_WINDOW_DAYS),
since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
limit: int = Query(default=30, ge=10, le=100),
@@ -2142,7 +2166,11 @@ async def stream_user_leaderboard_report(
raise HTTPException(status_code=503, detail="Analytics requires database persistence")
settings = load_system_settings().leaderboard
since_dt, until_dt, _range_days = _resolve_range(days, since, until)
since_dt, until_dt, _range_days = resolve_admin_query_window(
days=days,
since=since,
until=until,
)
resolved_model_name = _resolve_report_model_name(config, model_name)
cache_key = _report_cache_key(since=since_dt, until=until_dt, limit=limit, model_name=resolved_model_name, settings=settings)
@@ -2196,62 +2224,6 @@ async def stream_user_leaderboard_report(
)
@router.get("/{user_id}/analytics", response_model=AdminUserAnalyticsResponse)
async def get_user_analytics(
user_id: str,
request: Request,
days: int = Query(default=30, ge=1, le=365),
since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
limit: int = Query(default=20, ge=5, le=100),
) -> AdminUserAnalyticsResponse:
"""Return one user's admin analytics profile."""
await _require_admin(request)
session_factory = get_session_factory()
if session_factory is None:
raise HTTPException(status_code=503, detail="Analytics requires database persistence")
settings = load_system_settings().leaderboard
common = {
"include_scheduled": settings.include_scheduled,
"include_admins": settings.include_admins,
"include_failed": settings.include_failed,
}
tool_common = {
"include_scheduled": settings.include_scheduled,
"include_admins": settings.include_admins,
}
since_dt, until_dt, range_days = _resolve_range(days, since, until)
async with session_factory() as session:
await _set_analytics_read_timeout(session)
users = await _query_user_leaderboard(session, since_dt, until_dt, user_id=user_id, **common)
if not users:
raise HTTPException(status_code=404, detail="User not found")
overview = await _query_overview(session, since_dt, until_dt, user_id=user_id, **common)
skills = await _query_call_rankings(session, since_dt, until_dt, user_id=user_id, field="skill", limit=limit, **tool_common)
tools = await _query_call_rankings(session, since_dt, until_dt, user_id=user_id, field="tool", limit=limit, **tool_common)
models = await _query_model_rankings(session, since_dt, until_dt, user_id=user_id, limit=limit, **common)
if not models:
models = await _query_run_dimensions(session, since_dt, until_dt, user_id=user_id, field="model", limit=limit, **common)
agents = await _query_run_dimensions(session, since_dt, until_dt, user_id=user_id, field="agent", limit=limit, **common)
run_statuses = await _query_run_dimensions(session, since_dt, until_dt, user_id=user_id, field="status", limit=limit, **common)
trends = await _query_trends(session, since_dt, until_dt, user_id=user_id, **common)
return AdminUserAnalyticsResponse(
range_days=range_days,
since=_iso(since_dt),
until=_iso(until_dt),
user=users[0],
overview=overview,
skills=skills,
tools=tools,
models=models,
agents=agents,
run_statuses=run_statuses,
trends=trends,
)
# ── Q&A audit list ─────────────────────────────────────────────────────────
@@ -2321,7 +2293,12 @@ def _qa_message_text(message: Any) -> str:
return _message_content_to_text(_message_value(message, "content")).strip()
async def _read_thread_checkpoint_messages(checkpointer, thread_id: str) -> list[dict]:
async def _read_thread_checkpoint_messages(
checkpointer,
thread_id: str,
*,
max_messages: int | None = None,
) -> list[dict]:
config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
try:
checkpoint_tuple = await checkpointer.aget_tuple(config)
@@ -2334,7 +2311,9 @@ async def _read_thread_checkpoint_messages(checkpointer, thread_id: str) -> list
channel_values = checkpoint.get("channel_values", {}) if isinstance(checkpoint, dict) else {}
values = serialize_channel_values(channel_values)
messages = values.get("messages", [])
return messages if isinstance(messages, list) else []
if not isinstance(messages, list):
return []
return messages[-max_messages:] if max_messages else messages
def _qa_items_from_checkpoint_messages(
@@ -2402,47 +2381,97 @@ async def _list_thread_checkpoint_qa_items(
*,
request: Request,
user_id: str,
since: str | None = None,
until: str | None = None,
recent_only: bool = False,
) -> list[AdminUserQaItem]:
repo = get_thread_store(request)
checkpointer = get_checkpointer(request)
items: list[AdminUserQaItem] = []
offset = 0
page_size = 200
while True:
rows = await repo.search(limit=page_size, offset=offset, user_id=user_id)
if not rows:
break
for row in rows:
thread_id = str(row.get("thread_id") or "")
if not thread_id:
continue
messages = await _read_thread_checkpoint_messages(checkpointer, thread_id)
if not messages:
continue
metadata = row.get("metadata") if isinstance(row.get("metadata"), dict) else {}
context = row.get("context") if isinstance(row.get("context"), dict) else {}
assistant_id = str(
row.get("assistant_id")
or (context or {}).get("agent_id")
or (metadata or {}).get("agent_id")
or (context or {}).get("agent_name")
or (metadata or {}).get("agent_name")
or ""
)
thread_time = str(row.get("updated_at") or row.get("created_at") or "")
items.extend(
_qa_items_from_checkpoint_messages(
user_id=user_id,
thread_id=thread_id,
thread_title=str(row.get("display_name") or ""),
assistant_id=assistant_id,
thread_time=thread_time,
messages=messages,
rows: list[dict]
if recent_only:
# Checkpoints do not reliably carry a timestamp for every historical
# message. Limit the fallback to threads *created* in the effective
# audit window, so an old long-running conversation cannot leak a full
# history into a recent-only administrator query. Run summaries remain
# the complete, indexed source for recent messages in older threads.
session_factory = get_session_factory()
since_dt = _parse_optional_datetime(since)
until_dt = _parse_optional_datetime(until)
if session_factory is None or since_dt is None or until_dt is None:
return items
async with session_factory() as session:
await _set_analytics_read_timeout(session)
result = await session.execute(
select(ThreadMetaRow)
.where(
ThreadMetaRow.user_id == user_id,
ThreadMetaRow.created_at >= since_dt,
ThreadMetaRow.created_at <= until_dt,
)
.order_by(ThreadMetaRow.updated_at.desc(), ThreadMetaRow.thread_id.desc())
.limit(_ADMIN_QA_CHECKPOINT_THREAD_LIMIT)
)
if len(rows) < page_size:
break
offset += len(rows)
rows = [
{
"thread_id": row.thread_id,
"assistant_id": row.assistant_id,
"display_name": row.display_name,
"metadata": row.metadata_json or {},
"created_at": _iso(row.created_at),
"updated_at": _iso(row.updated_at),
}
for row in result.scalars()
]
else:
# Preserve the regular user's existing history behavior. The bounded
# administrator route always takes the SQL path above.
repo = get_thread_store(request)
rows = []
offset = 0
page_size = 200
while True:
page = await repo.search(limit=page_size, offset=offset, user_id=user_id)
if not page:
break
rows.extend(page)
if len(page) < page_size:
break
offset += len(page)
for row in rows:
thread_id = str(row.get("thread_id") or "")
if not thread_id:
continue
messages = await _read_thread_checkpoint_messages(
checkpointer,
thread_id,
max_messages=_ADMIN_QA_CHECKPOINT_MESSAGE_LIMIT if recent_only else None,
)
if not messages:
continue
metadata = row.get("metadata") if isinstance(row.get("metadata"), dict) else {}
context = row.get("context") if isinstance(row.get("context"), dict) else {}
assistant_id = str(
row.get("assistant_id")
or (context or {}).get("agent_id")
or (metadata or {}).get("agent_id")
or (context or {}).get("agent_name")
or (metadata or {}).get("agent_name")
or ""
)
thread_time = str(row.get("updated_at") or row.get("created_at") or "")
items.extend(
_qa_items_from_checkpoint_messages(
user_id=user_id,
thread_id=thread_id,
thread_title=str(row.get("display_name") or ""),
assistant_id=assistant_id,
thread_time=thread_time,
messages=messages,
)
)
if recent_only and len(items) >= _ADMIN_QA_CHECKPOINT_ITEM_LIMIT:
return items[:_ADMIN_QA_CHECKPOINT_ITEM_LIMIT]
return items
@@ -2452,44 +2481,61 @@ async def _list_run_summary_qa_items(
user_id: str,
since: str | None,
until: str | None,
q: str | None = None,
candidate_limit: int | None = None,
) -> list[AdminUserQaItem]:
filters = [
RunRow.user_id == user_id,
RunRow.first_human_message.is_not(None),
RunRow.first_human_message != "",
]
if since or until:
since_dt, until_dt, _range_days = _resolve_range(365, since, until)
filters.append(_run_time_filter(since_dt, until_dt))
if since:
filters.append(RunRow.created_at >= _parse_optional_datetime(since))
if until:
filters.append(RunRow.created_at <= _parse_optional_datetime(until))
needle = (q or "").strip().lower()
if needle:
like = f"%{needle}%"
filters.append(
or_(
func.lower(RunRow.run_id).like(like),
func.lower(RunRow.thread_id).like(like),
func.lower(func.coalesce(RunRow.assistant_id, "")).like(like),
func.lower(func.coalesce(RunRow.first_human_message, "")).like(like),
func.lower(func.coalesce(RunRow.last_ai_message, "")).like(like),
func.lower(func.coalesce(ThreadMetaRow.display_name, "")).like(like),
)
)
async with session_factory() as session:
await _set_analytics_read_timeout(session)
rows = (
await session.execute(
select(
RunRow.run_id,
RunRow.thread_id,
ThreadMetaRow.display_name,
RunRow.assistant_id,
RunRow.status,
RunRow.model_name,
RunRow.first_human_message,
RunRow.last_ai_message,
RunRow.total_tokens,
RunRow.created_at,
RunRow.updated_at,
)
.outerjoin(
ThreadMetaRow,
and_(
ThreadMetaRow.thread_id == RunRow.thread_id,
ThreadMetaRow.user_id == RunRow.user_id,
),
)
.where(*filters)
.order_by(RunRow.created_at.desc(), RunRow.run_id.desc())
stmt = (
select(
RunRow.run_id,
RunRow.thread_id,
ThreadMetaRow.display_name,
RunRow.assistant_id,
RunRow.status,
RunRow.model_name,
RunRow.first_human_message,
RunRow.last_ai_message,
RunRow.total_tokens,
RunRow.created_at,
RunRow.updated_at,
)
).all()
.outerjoin(
ThreadMetaRow,
and_(
ThreadMetaRow.thread_id == RunRow.thread_id,
ThreadMetaRow.user_id == RunRow.user_id,
),
)
.where(*filters)
.order_by(RunRow.created_at.desc(), RunRow.run_id.desc())
)
if candidate_limit is not None:
stmt = stmt.limit(max(1, min(int(candidate_limit), _ADMIN_QA_RUN_CANDIDATE_LIMIT)))
rows = (await session.execute(stmt)).all()
return [
AdminUserQaItem(
@@ -2554,19 +2600,39 @@ async def _list_user_qa_page(
since: str | None,
until: str | None,
include_checkpoints: bool = True,
recent_checkpoint_threads_only: bool = False,
) -> AdminUserQaPageResponse:
session_factory = get_session_factory()
if session_factory is None:
raise HTTPException(status_code=503, detail="Q&A audit requires database persistence")
candidate_limit = None
if recent_checkpoint_threads_only:
# Normal administrator pages need only a modest look-ahead beyond the
# requested page. This protects against a single high-frequency user
# materializing a whole month's question/answer bodies at once.
candidate_limit = min(
_ADMIN_QA_RUN_CANDIDATE_LIMIT,
max(200, page * page_size + page_size),
)
items = await _list_run_summary_qa_items(
session_factory=session_factory,
user_id=user_id,
since=since,
until=until,
q=q if candidate_limit is not None else None,
candidate_limit=candidate_limit,
)
if include_checkpoints:
items.extend(await _list_thread_checkpoint_qa_items(request=request, user_id=user_id))
items.extend(
await _list_thread_checkpoint_qa_items(
request=request,
user_id=user_id,
since=since,
until=until,
recent_only=recent_checkpoint_threads_only,
)
)
by_key: dict[tuple[str, str, str], AdminUserQaItem] = {}
for item in items:
@@ -2594,22 +2660,24 @@ async def _list_user_qa_page(
async def list_user_qa(
user_id: str,
request: Request,
page: int = Query(default=1, ge=1),
page: int = Query(default=1, ge=1, le=100),
page_size: int = Query(default=20, ge=1, le=100),
q: str | None = Query(default=None, description="Search question, answer, run id, or thread id"),
since: str | None = Query(default=None, description="Inclusive range start, ISO datetime"),
until: str | None = Query(default=None, description="Inclusive range end, ISO datetime"),
) -> AdminUserQaPageResponse:
"""Return one user's Q&A runs, including older checkpoint-only threads."""
"""Return one user's recent Q&A audit records."""
await _require_admin(request)
since_dt, until_dt, _range_days = resolve_admin_query_window(since=since, until=until)
return await _list_user_qa_page(
request=request,
user_id=user_id,
page=page,
page_size=page_size,
q=q,
since=since,
until=until,
since=_iso(since_dt),
until=_iso(until_dt),
recent_checkpoint_threads_only=True,
)
@@ -2652,11 +2720,41 @@ class AdminThreadItem(BaseModel):
async def list_user_threads(
user_id: str,
request: Request,
limit: int = Query(default=100, ge=1, le=500),
limit: int = Query(default=100, ge=1, le=200),
offset: int = Query(default=0, ge=0),
) -> list[AdminThreadItem]:
"""List one user's conversation threads, newest first."""
"""List one user's threads active in the rolling administrator window."""
await _require_admin(request)
cutoff, _until, _range_days = resolve_admin_query_window()
session_factory = get_session_factory()
if session_factory is not None:
async with session_factory() as session:
await _set_analytics_read_timeout(session)
rows = (
await session.execute(
select(ThreadMetaRow)
.where(
ThreadMetaRow.user_id == user_id,
ThreadMetaRow.updated_at >= cutoff,
)
.order_by(ThreadMetaRow.updated_at.desc(), ThreadMetaRow.thread_id.desc())
.limit(limit)
.offset(offset)
)
).scalars().all()
return [
AdminThreadItem(
thread_id=row.thread_id,
display_name=row.display_name or "",
status=row.status or "idle",
created_at=_iso(row.created_at),
updated_at=_iso(row.updated_at),
)
for row in rows
]
# Memory-mode fallback has no SQL date predicate. It is only used when
# database persistence is unavailable, and still preserves the policy.
repo = get_thread_store(request)
rows = await repo.search(limit=limit, offset=offset, user_id=user_id)
return [
@@ -2668,6 +2766,7 @@ async def list_user_threads(
updated_at=str(r.get("updated_at") or ""),
)
for r in rows
if _qa_sort_datetime(str(r.get("updated_at") or "")) >= cutoff
]
@@ -2676,7 +2775,7 @@ async def list_user_thread_messages(
user_id: str,
thread_id: str,
request: Request,
limit: int = Query(default=400, ge=1, le=1000),
limit: int = Query(default=200, ge=1, le=200),
) -> list[dict]:
"""Return the conversation messages of one of the user's threads.
@@ -2695,6 +2794,12 @@ async def list_user_thread_messages(
owner = thread.get("user_id")
if owner is not None and owner != user_id:
raise HTTPException(status_code=404, detail="Thread does not belong to this user")
cutoff, _until, _range_days = resolve_admin_query_window()
if _qa_sort_datetime(str(thread.get("updated_at") or thread.get("created_at") or "")) < cutoff:
raise HTTPException(
status_code=404,
detail=f"仅可查看最近 {ADMIN_QUERY_WINDOW_DAYS} 天的审计会话",
)
checkpointer = get_checkpointer(request)
config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}