Merge branch 'master' of http://192.168.0.200/knowledge-base-bj/deerflow-server into dhk-1
This commit is contained in:
commit
226439ef36
100 files changed
+12966
-7151
No files matched your search
@@ -23,6 +23,7 @@ from app.gateway.csrf_middleware import CSRFMiddleware
|
||||
from app.gateway.deps import langgraph_runtime
|
||||
from app.gateway.routers import (
|
||||
ai_writing,
|
||||
admin_users,
|
||||
agents,
|
||||
artifacts,
|
||||
assistants_compat,
|
||||
@@ -42,6 +43,7 @@ from app.gateway.routers import (
|
||||
system_settings,
|
||||
tags,
|
||||
thread_runs,
|
||||
tool_metrics,
|
||||
thread_shares,
|
||||
threads,
|
||||
uploads,
|
||||
@@ -256,7 +258,7 @@ async def _run_db_migrations() -> None:
|
||||
logger.info("Persistence backend=memory — skipping Alembic migrations")
|
||||
return
|
||||
|
||||
db_url = engine.url.render_as_string(hide_password=False).replace("%", "%%")
|
||||
db_url = engine.url.render_as_string(hide_password=False).replace("%", "%%")
|
||||
migrations_dir = str(Path(_persistence_pkg.__file__).parent / "migrations")
|
||||
|
||||
def _run_sync() -> None:
|
||||
@@ -689,6 +691,12 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
|
||||
# Admin LLM metrics audit + export
|
||||
app.include_router(llm_metrics.router)
|
||||
|
||||
# Admin window into other users' threads / messages / memory
|
||||
app.include_router(admin_users.router)
|
||||
|
||||
# Admin tool / skill call metrics audit + export
|
||||
app.include_router(tool_metrics.router)
|
||||
|
||||
# Channels API is mounted at /api/channels
|
||||
app.include_router(channels.router)
|
||||
|
||||
|
||||
@@ -97,6 +97,10 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
|
||||
|
||||
app.state.llm_metrics_store = make_llm_metrics_store(sf)
|
||||
|
||||
from deerflow.persistence.tool_metrics import make_tool_metrics_store
|
||||
|
||||
app.state.tool_metrics_store = make_tool_metrics_store(sf)
|
||||
|
||||
from deerflow.persistence.agents import make_agent_store
|
||||
|
||||
app.state.agent_store = make_agent_store(sf)
|
||||
@@ -202,6 +206,11 @@ def get_llm_metrics_store(request: Request):
|
||||
return getattr(request.app.state, "llm_metrics_store", None)
|
||||
|
||||
|
||||
def get_tool_metrics_store(request: Request):
|
||||
"""Return the tool-call metrics store, or None when not configured."""
|
||||
return getattr(request.app.state, "tool_metrics_store", None)
|
||||
|
||||
|
||||
def get_agent_store(request: Request) -> AgentStore:
|
||||
"""Return the custom-agent store."""
|
||||
val = getattr(request.app.state, "agent_store", None)
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
"""Admin-only window into another user's activity.
|
||||
|
||||
Lets an administrator inspect any user's conversation history (threads + the
|
||||
Q&A messages inside them) and their accumulated memory (global + per-agent
|
||||
buckets). All endpoints require ``system_role == "admin"``; they are strictly
|
||||
read-only.
|
||||
|
||||
The underlying stores normally auto-scope every query to the *calling* user
|
||||
via a contextvar. These endpoints pass an explicit ``user_id`` so the admin
|
||||
reads the *target* user's data instead — which is exactly what those store
|
||||
methods' ``user_id`` parameter is designed for.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query, Request
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.gateway.deps import (
|
||||
get_checkpointer,
|
||||
get_current_user_from_request,
|
||||
get_thread_store,
|
||||
)
|
||||
from deerflow.agents.memory import BuiltinFileProvider
|
||||
from deerflow.config.agents_config import AGENT_NAME_PATTERN
|
||||
from deerflow.config.paths import get_paths
|
||||
from deerflow.runtime import serialize_channel_values
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
router = APIRouter(prefix="/api/admin/users", tags=["admin-users"])
|
||||
|
||||
|
||||
async def _require_admin(request: Request) -> None:
|
||||
"""Reject non-admin callers. In no-auth mode there is no user → allow."""
|
||||
try:
|
||||
user = await get_current_user_from_request(request)
|
||||
except HTTPException:
|
||||
raise
|
||||
if user is None:
|
||||
return
|
||||
if getattr(user, "system_role", None) != "admin":
|
||||
raise HTTPException(status_code=403, detail="Admin only")
|
||||
|
||||
|
||||
# ── Threads ────────────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
class AdminThreadItem(BaseModel):
|
||||
thread_id: str
|
||||
display_name: str = ""
|
||||
status: str = "idle"
|
||||
created_at: str = ""
|
||||
updated_at: str = ""
|
||||
|
||||
|
||||
@router.get("/{user_id}/threads", response_model=list[AdminThreadItem])
|
||||
async def list_user_threads(
|
||||
user_id: str,
|
||||
request: Request,
|
||||
limit: int = Query(default=100, ge=1, le=500),
|
||||
offset: int = Query(default=0, ge=0),
|
||||
) -> list[AdminThreadItem]:
|
||||
"""List one user's conversation threads, newest first."""
|
||||
await _require_admin(request)
|
||||
repo = get_thread_store(request)
|
||||
rows = await repo.search(limit=limit, offset=offset, user_id=user_id)
|
||||
return [
|
||||
AdminThreadItem(
|
||||
thread_id=r["thread_id"],
|
||||
display_name=r.get("display_name") or "",
|
||||
status=r.get("status", "idle"),
|
||||
created_at=str(r.get("created_at") or ""),
|
||||
updated_at=str(r.get("updated_at") or ""),
|
||||
)
|
||||
for r in rows
|
||||
]
|
||||
|
||||
|
||||
@router.get("/{user_id}/threads/{thread_id}/messages", response_model=list[dict])
|
||||
async def list_user_thread_messages(
|
||||
user_id: str,
|
||||
thread_id: str,
|
||||
request: Request,
|
||||
limit: int = Query(default=400, ge=1, le=1000),
|
||||
) -> list[dict]:
|
||||
"""Return the conversation messages of one of the user's threads.
|
||||
|
||||
Read straight from the LangGraph checkpoint — the same source the chat UI
|
||||
renders — rather than the optional ``run_events`` audit log, which may be
|
||||
unconfigured (``run_events.backend=memory``) or empty for older threads.
|
||||
"""
|
||||
await _require_admin(request)
|
||||
|
||||
repo = get_thread_store(request)
|
||||
# ``user_id=None`` bypasses the owner filter so the admin can fetch any row;
|
||||
# we then assert the thread really belongs to the target user.
|
||||
thread = await repo.get(thread_id, user_id=None)
|
||||
if thread is None:
|
||||
raise HTTPException(status_code=404, detail="Thread not found")
|
||||
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")
|
||||
|
||||
checkpointer = get_checkpointer(request)
|
||||
config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
|
||||
try:
|
||||
checkpoint_tuple = await checkpointer.aget_tuple(config)
|
||||
except Exception as exc: # noqa: BLE001 - surface a clean error
|
||||
logger.error("Failed to read checkpoint for thread %s: %s", thread_id, exc, exc_info=True)
|
||||
raise HTTPException(status_code=500, detail="Failed to read thread state") from exc
|
||||
if checkpoint_tuple is None:
|
||||
return []
|
||||
|
||||
checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
|
||||
channel_values = checkpoint.get("channel_values", {}) if isinstance(checkpoint, dict) else {}
|
||||
values = serialize_channel_values(channel_values)
|
||||
messages = values.get("messages", [])
|
||||
if not isinstance(messages, list):
|
||||
return []
|
||||
# Keep the most recent ``limit`` messages — long threads stay bounded.
|
||||
return messages[-limit:]
|
||||
|
||||
|
||||
# ── Memory ─────────────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
class AdminMemoryBucket(BaseModel):
|
||||
name: str = Field(..., description="Bucket name: 'global' or a custom-agent name")
|
||||
data: dict = Field(default_factory=dict, description="Raw memory data for the bucket")
|
||||
|
||||
|
||||
class AdminMemoryResponse(BaseModel):
|
||||
user_id: str
|
||||
buckets: list[AdminMemoryBucket] = Field(default_factory=list)
|
||||
|
||||
|
||||
def _read_memory_bucket(user_id: str, agent_id: str | None) -> dict:
|
||||
"""Read one Memory V2 file into a JSON-able ``{"entries": [...]}`` dict.
|
||||
|
||||
``agent_id is None`` -> the user's ``USER.md`` (profile, cross-agent);
|
||||
otherwise that agent's ``MEMORY.md`` (per-agent working notes).
|
||||
"""
|
||||
provider = BuiltinFileProvider()
|
||||
provider.initialize(user_id=user_id, agent_id=agent_id)
|
||||
target = "user" if agent_id is None else "memory"
|
||||
return {"entries": provider.read(target)}
|
||||
|
||||
|
||||
@router.get("/{user_id}/memory", response_model=AdminMemoryResponse)
|
||||
async def get_user_memory(user_id: str, request: Request) -> AdminMemoryResponse:
|
||||
"""Return every memory bucket for one user.
|
||||
|
||||
Memory V2 layout: the ``global`` bucket is ``USER.md`` (user profile);
|
||||
each per-agent bucket is that agent's ``MEMORY.md`` working notes.
|
||||
"""
|
||||
await _require_admin(request)
|
||||
|
||||
buckets: list[AdminMemoryBucket] = [
|
||||
AdminMemoryBucket(name="global", data=_read_memory_bucket(user_id, None))
|
||||
]
|
||||
|
||||
agents_root = get_paths().user_dir(user_id) / "agents"
|
||||
if agents_root.is_dir():
|
||||
for entry in sorted(agents_root.iterdir(), key=lambda p: p.name.lower()):
|
||||
if not entry.is_dir() or not (entry / "MEMORY.md").exists():
|
||||
continue
|
||||
if not AGENT_NAME_PATTERN.match(entry.name):
|
||||
continue
|
||||
try:
|
||||
data = _read_memory_bucket(user_id, entry.name)
|
||||
except Exception:
|
||||
logger.warning("Failed to read memory bucket %s for user", entry.name)
|
||||
continue
|
||||
buckets.append(AdminMemoryBucket(name=entry.name, data=data))
|
||||
|
||||
return AdminMemoryResponse(user_id=user_id, buckets=buckets)
|
||||
@@ -244,7 +244,7 @@ async def _get_editable_or_raise(
|
||||
async def list_agents(
|
||||
request: Request,
|
||||
search: str | None = Query(default=None, description="Case-insensitive fuzzy match on agent name"),
|
||||
tag_id: str | None = Query(default=None, description="Keep only agents carrying this tag"),
|
||||
tag_ids: list[str] | None = Query(default=None, description="Keep agents carrying any of these tags (OR)"),
|
||||
) -> AgentsListResponse:
|
||||
_require_agents_api_enabled()
|
||||
|
||||
@@ -262,8 +262,9 @@ async def list_agents(
|
||||
if search:
|
||||
needle = search.strip().lower()
|
||||
responses = [r for r in responses if needle in r.name.lower()]
|
||||
if tag_id:
|
||||
responses = [r for r in responses if any(t.get("id") == tag_id for t in r.tags)]
|
||||
if tag_ids:
|
||||
wanted = set(tag_ids)
|
||||
responses = [r for r in responses if any(t.get("id") in wanted for t in r.tags)]
|
||||
return AgentsListResponse(agents=responses)
|
||||
except HTTPException:
|
||||
raise
|
||||
|
||||
@@ -1,531 +1,385 @@
|
||||
"""Memory API router for retrieving and managing memory data.
|
||||
|
||||
All endpoints accept an optional ``agent`` query parameter:
|
||||
|
||||
- omitted / empty / ``"global"`` -> operate on the per-user **global**
|
||||
memory file (``users/{uid}/memory.json``).
|
||||
- valid agent name -> operate on the **per-agent** memory file
|
||||
(``users/{uid}/agents/{agent}/memory.json``).
|
||||
|
||||
Without this parameter the API used to be silently global-only, so any
|
||||
memory written while chatting inside a custom agent (which is saved
|
||||
per-agent) was invisible from the settings page. See ``GET /api/memory/agents``
|
||||
for discovering which agent-scoped buckets the current user owns.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from deerflow.agents.memory.updater import (
|
||||
clear_memory_data,
|
||||
create_memory_fact,
|
||||
delete_memory_fact,
|
||||
get_memory_data,
|
||||
import_memory_data,
|
||||
reload_memory_data,
|
||||
update_memory_fact,
|
||||
)
|
||||
from deerflow.config.agents_config import AGENT_NAME_PATTERN
|
||||
from deerflow.config.memory_config import get_memory_config
|
||||
from deerflow.config.paths import get_paths
|
||||
from deerflow.runtime.user_context import get_effective_user_id
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["memory"])
|
||||
|
||||
|
||||
# Sentinel values that mean "the per-user global memory file" (no agent).
|
||||
# We accept several spellings so the frontend can model the dropdown choice
|
||||
# either by omitting the param or by sending an explicit "global"/"".
|
||||
_GLOBAL_AGENT_VALUES: frozenset[str] = frozenset({"", "global", "__global__"})
|
||||
|
||||
|
||||
def _resolve_agent_name(agent: str | None) -> str | None:
|
||||
"""Validate the ``agent`` query parameter and normalize the global sentinel.
|
||||
|
||||
Returns ``None`` for the global memory bucket, or the lowercased agent
|
||||
name otherwise. Raises 400 if the supplied name fails the agent-name
|
||||
pattern (mirrors :func:`FileMemoryStorage._validate_agent_name`, but
|
||||
surfaces a clean HTTP error instead of letting the storage layer raise
|
||||
``ValueError`` via a 500).
|
||||
"""
|
||||
if agent is None:
|
||||
return None
|
||||
stripped = agent.strip()
|
||||
if stripped.lower() in _GLOBAL_AGENT_VALUES:
|
||||
return None
|
||||
if not AGENT_NAME_PATTERN.match(stripped):
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Invalid agent name {stripped!r}: must match {AGENT_NAME_PATTERN.pattern}",
|
||||
)
|
||||
return stripped.lower()
|
||||
|
||||
|
||||
_AgentQuery = Query(
|
||||
None,
|
||||
description=(
|
||||
"Optional agent name. Omit (or pass 'global') to address the per-user "
|
||||
"global memory bucket; pass a custom-agent name to address that "
|
||||
"agent's per-user memory bucket."
|
||||
),
|
||||
examples=["my-agent"],
|
||||
pattern=r"^[A-Za-z0-9-]+$|^global$|^$",
|
||||
)
|
||||
|
||||
|
||||
class ContextSection(BaseModel):
|
||||
"""Model for context sections (user and history)."""
|
||||
|
||||
summary: str = Field(default="", description="Summary content")
|
||||
updatedAt: str = Field(default="", description="Last update timestamp")
|
||||
|
||||
|
||||
class UserContext(BaseModel):
|
||||
"""Model for user context."""
|
||||
|
||||
workContext: ContextSection = Field(default_factory=ContextSection)
|
||||
personalContext: ContextSection = Field(default_factory=ContextSection)
|
||||
topOfMind: ContextSection = Field(default_factory=ContextSection)
|
||||
|
||||
|
||||
class HistoryContext(BaseModel):
|
||||
"""Model for history context."""
|
||||
|
||||
recentMonths: ContextSection = Field(default_factory=ContextSection)
|
||||
earlierContext: ContextSection = Field(default_factory=ContextSection)
|
||||
longTermBackground: ContextSection = Field(default_factory=ContextSection)
|
||||
|
||||
|
||||
class Fact(BaseModel):
|
||||
"""Model for a memory fact."""
|
||||
|
||||
id: str = Field(..., description="Unique identifier for the fact")
|
||||
content: str = Field(..., description="Fact content")
|
||||
category: str = Field(default="context", description="Fact category")
|
||||
confidence: float = Field(default=0.5, description="Confidence score (0-1)")
|
||||
createdAt: str = Field(default="", description="Creation timestamp")
|
||||
source: str = Field(default="unknown", description="Source thread ID")
|
||||
sourceError: str | None = Field(default=None, description="Optional description of the prior mistake or wrong approach")
|
||||
|
||||
|
||||
class MemoryResponse(BaseModel):
|
||||
"""Response model for memory data."""
|
||||
|
||||
version: str = Field(default="1.0", description="Memory schema version")
|
||||
lastUpdated: str = Field(default="", description="Last update timestamp")
|
||||
user: UserContext = Field(default_factory=UserContext)
|
||||
history: HistoryContext = Field(default_factory=HistoryContext)
|
||||
facts: list[Fact] = Field(default_factory=list)
|
||||
|
||||
|
||||
def _map_memory_fact_value_error(exc: ValueError) -> HTTPException:
|
||||
"""Convert updater validation errors into stable API responses."""
|
||||
if exc.args and exc.args[0] == "confidence":
|
||||
detail = "Invalid confidence value; must be between 0 and 1."
|
||||
else:
|
||||
detail = "Memory fact content cannot be empty."
|
||||
return HTTPException(status_code=400, detail=detail)
|
||||
|
||||
|
||||
class FactCreateRequest(BaseModel):
|
||||
"""Request model for creating a memory fact."""
|
||||
|
||||
content: str = Field(..., min_length=1, description="Fact content")
|
||||
category: str = Field(default="context", description="Fact category")
|
||||
confidence: float = Field(default=0.5, ge=0.0, le=1.0, description="Confidence score (0-1)")
|
||||
|
||||
|
||||
class FactPatchRequest(BaseModel):
|
||||
"""PATCH request model that preserves existing values for omitted fields."""
|
||||
|
||||
content: str | None = Field(default=None, min_length=1, description="Fact content")
|
||||
category: str | None = Field(default=None, description="Fact category")
|
||||
confidence: float | None = Field(default=None, ge=0.0, le=1.0, description="Confidence score (0-1)")
|
||||
|
||||
|
||||
class MemoryConfigResponse(BaseModel):
|
||||
"""Response model for memory configuration."""
|
||||
|
||||
enabled: bool = Field(..., description="Whether memory is enabled")
|
||||
storage_path: str = Field(..., description="Path to memory storage file")
|
||||
debounce_seconds: int = Field(..., description="Debounce time for memory updates")
|
||||
max_facts: int = Field(..., description="Maximum number of facts to store")
|
||||
fact_confidence_threshold: float = Field(..., description="Minimum confidence threshold for facts")
|
||||
injection_enabled: bool = Field(..., description="Whether memory injection is enabled")
|
||||
max_injection_tokens: int = Field(..., description="Maximum tokens for memory injection")
|
||||
|
||||
|
||||
class MemoryStatusResponse(BaseModel):
|
||||
"""Response model for memory status."""
|
||||
|
||||
config: MemoryConfigResponse
|
||||
data: MemoryResponse
|
||||
|
||||
|
||||
class MemoryAgentInfo(BaseModel):
|
||||
"""One per-agent memory bucket the current user owns."""
|
||||
|
||||
name: str = Field(..., description="Custom agent name (matches AGENT_NAME_PATTERN).")
|
||||
factCount: int = Field(0, description="Number of facts stored for this agent.")
|
||||
lastUpdated: str = Field("", description="lastUpdated field of the per-agent memory file, if any.")
|
||||
|
||||
|
||||
class MemoryAgentsResponse(BaseModel):
|
||||
"""Inventory of memory buckets visible to the current user."""
|
||||
|
||||
globalAvailable: bool = Field(..., description="Whether a per-user global memory file exists on disk.")
|
||||
globalFactCount: int = Field(0, description="Facts in the per-user global memory file.")
|
||||
globalLastUpdated: str = Field("", description="lastUpdated field of the global memory file, if any.")
|
||||
agents: list[MemoryAgentInfo] = Field(default_factory=list, description="Sorted by name (case-insensitive).")
|
||||
|
||||
|
||||
@router.get(
|
||||
"/memory/agents",
|
||||
response_model=MemoryAgentsResponse,
|
||||
summary="List Memory Buckets",
|
||||
description=(
|
||||
"Enumerate which memory buckets exist for the current user: the "
|
||||
"per-user global file, plus every per-agent memory file the user "
|
||||
"has accumulated by chatting inside custom agents. Drives the "
|
||||
"agent-selector dropdown on the Memory settings page."
|
||||
),
|
||||
)
|
||||
async def list_memory_agents() -> MemoryAgentsResponse:
|
||||
"""Inspect the on-disk memory layout for the current user.
|
||||
|
||||
This intentionally walks the filesystem instead of querying the
|
||||
custom-agents API: a user can have leftover per-agent memory for an
|
||||
agent they later renamed/deleted, and we still want them to be able to
|
||||
open it (or clear it) from the UI.
|
||||
"""
|
||||
import json
|
||||
|
||||
user_id = get_effective_user_id()
|
||||
paths = get_paths()
|
||||
user_dir = paths.user_dir(user_id)
|
||||
|
||||
# Global bucket
|
||||
global_file = paths.user_memory_file(user_id)
|
||||
global_available = global_file.exists()
|
||||
global_facts = 0
|
||||
global_updated = ""
|
||||
if global_available:
|
||||
try:
|
||||
with open(global_file, encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
global_facts = len(data.get("facts", []) or [])
|
||||
global_updated = data.get("lastUpdated", "") or ""
|
||||
except (OSError, json.JSONDecodeError):
|
||||
# Treat unreadable file as "exists but empty" — better than 500
|
||||
# since this endpoint is purely informational.
|
||||
pass
|
||||
|
||||
agents: list[MemoryAgentInfo] = []
|
||||
agents_root = user_dir / "agents"
|
||||
if agents_root.is_dir():
|
||||
for entry in sorted(agents_root.iterdir(), key=lambda p: p.name.lower()):
|
||||
if not entry.is_dir():
|
||||
continue
|
||||
mem_file = entry / "memory.json"
|
||||
if not mem_file.exists():
|
||||
continue
|
||||
# Defensive: agent-dir name may have been hand-edited; keep only
|
||||
# those that round-trip through AGENT_NAME_PATTERN so the UI
|
||||
# never receives a value it can't echo back to us.
|
||||
if not AGENT_NAME_PATTERN.match(entry.name):
|
||||
continue
|
||||
facts = 0
|
||||
updated = ""
|
||||
try:
|
||||
with open(mem_file, encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
facts = len(data.get("facts", []) or [])
|
||||
updated = data.get("lastUpdated", "") or ""
|
||||
except (OSError, json.JSONDecodeError):
|
||||
pass
|
||||
agents.append(MemoryAgentInfo(name=entry.name, factCount=facts, lastUpdated=updated))
|
||||
|
||||
return MemoryAgentsResponse(
|
||||
globalAvailable=global_available,
|
||||
globalFactCount=global_facts,
|
||||
globalLastUpdated=global_updated,
|
||||
agents=agents,
|
||||
)
|
||||
|
||||
|
||||
@router.get(
|
||||
"/memory",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Get Memory Data",
|
||||
description=(
|
||||
"Retrieve the current memory data including user context, history, and facts. "
|
||||
"Pass ``?agent=<name>`` to read a per-agent bucket; omit it to read the per-user global bucket."
|
||||
),
|
||||
)
|
||||
async def get_memory(agent: str | None = _AgentQuery) -> MemoryResponse:
|
||||
"""Get the current memory data for the global or per-agent bucket.
|
||||
|
||||
Returns:
|
||||
The current memory data with user context, history, and facts.
|
||||
|
||||
Example Response:
|
||||
```json
|
||||
{
|
||||
"version": "1.0",
|
||||
"lastUpdated": "2024-01-15T10:30:00Z",
|
||||
"user": {
|
||||
"workContext": {"summary": "Working on DeerFlow project", "updatedAt": "..."},
|
||||
"personalContext": {"summary": "Prefers concise responses", "updatedAt": "..."},
|
||||
"topOfMind": {"summary": "Building memory API", "updatedAt": "..."}
|
||||
},
|
||||
"history": {
|
||||
"recentMonths": {"summary": "Recent development activities", "updatedAt": "..."},
|
||||
"earlierContext": {"summary": "", "updatedAt": ""},
|
||||
"longTermBackground": {"summary": "", "updatedAt": ""}
|
||||
},
|
||||
"facts": [
|
||||
{
|
||||
"id": "fact_abc123",
|
||||
"content": "User prefers TypeScript over JavaScript",
|
||||
"category": "preference",
|
||||
"confidence": 0.9,
|
||||
"createdAt": "2024-01-15T10:30:00Z",
|
||||
"source": "thread_xyz"
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
"""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
memory_data = get_memory_data(agent_name, user_id=get_effective_user_id())
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/memory/reload",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Reload Memory Data",
|
||||
description="Reload memory data from the storage file, refreshing the in-memory cache.",
|
||||
)
|
||||
async def reload_memory(agent: str | None = _AgentQuery) -> MemoryResponse:
|
||||
"""Reload memory data from file.
|
||||
|
||||
This forces a reload of the memory data from the storage file,
|
||||
useful when the file has been modified externally.
|
||||
|
||||
Returns:
|
||||
The reloaded memory data.
|
||||
"""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
memory_data = reload_memory_data(agent_name, user_id=get_effective_user_id())
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.delete(
|
||||
"/memory",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Clear All Memory Data",
|
||||
description="Delete all saved memory data and reset the memory structure to an empty state.",
|
||||
)
|
||||
async def clear_memory(agent: str | None = _AgentQuery) -> MemoryResponse:
|
||||
"""Clear all persisted memory data for the requested bucket."""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
try:
|
||||
memory_data = clear_memory_data(agent_name, user_id=get_effective_user_id())
|
||||
except OSError as exc:
|
||||
raise HTTPException(status_code=500, detail="Failed to clear memory data.") from exc
|
||||
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/memory/facts",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Create Memory Fact",
|
||||
description="Create a single saved memory fact manually.",
|
||||
)
|
||||
async def create_memory_fact_endpoint(
|
||||
request: FactCreateRequest,
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemoryResponse:
|
||||
"""Create a single fact manually."""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
try:
|
||||
memory_data = create_memory_fact(
|
||||
content=request.content,
|
||||
category=request.category,
|
||||
confidence=request.confidence,
|
||||
agent_name=agent_name,
|
||||
user_id=get_effective_user_id(),
|
||||
)
|
||||
except ValueError as exc:
|
||||
raise _map_memory_fact_value_error(exc) from exc
|
||||
except OSError as exc:
|
||||
raise HTTPException(status_code=500, detail="Failed to create memory fact.") from exc
|
||||
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.delete(
|
||||
"/memory/facts/{fact_id}",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Delete Memory Fact",
|
||||
description="Delete a single saved memory fact by its fact id.",
|
||||
)
|
||||
async def delete_memory_fact_endpoint(
|
||||
fact_id: str,
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemoryResponse:
|
||||
"""Delete a single fact from memory by fact id."""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
try:
|
||||
memory_data = delete_memory_fact(fact_id, agent_name, user_id=get_effective_user_id())
|
||||
except KeyError as exc:
|
||||
raise HTTPException(status_code=404, detail=f"Memory fact '{fact_id}' not found.") from exc
|
||||
except OSError as exc:
|
||||
raise HTTPException(status_code=500, detail="Failed to delete memory fact.") from exc
|
||||
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.patch(
|
||||
"/memory/facts/{fact_id}",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Patch Memory Fact",
|
||||
description="Partially update a single saved memory fact by its fact id while preserving omitted fields.",
|
||||
)
|
||||
async def update_memory_fact_endpoint(
|
||||
fact_id: str,
|
||||
request: FactPatchRequest,
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemoryResponse:
|
||||
"""Partially update a single fact manually."""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
try:
|
||||
memory_data = update_memory_fact(
|
||||
fact_id=fact_id,
|
||||
content=request.content,
|
||||
category=request.category,
|
||||
confidence=request.confidence,
|
||||
agent_name=agent_name,
|
||||
user_id=get_effective_user_id(),
|
||||
)
|
||||
except ValueError as exc:
|
||||
raise _map_memory_fact_value_error(exc) from exc
|
||||
except KeyError as exc:
|
||||
raise HTTPException(status_code=404, detail=f"Memory fact '{fact_id}' not found.") from exc
|
||||
except OSError as exc:
|
||||
raise HTTPException(status_code=500, detail="Failed to update memory fact.") from exc
|
||||
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.get(
|
||||
"/memory/export",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Export Memory Data",
|
||||
description="Export the current global memory data as JSON for backup or transfer.",
|
||||
)
|
||||
async def export_memory(agent: str | None = _AgentQuery) -> MemoryResponse:
|
||||
"""Export the current memory data."""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
memory_data = get_memory_data(agent_name, user_id=get_effective_user_id())
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/memory/import",
|
||||
response_model=MemoryResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Import Memory Data",
|
||||
description="Import and overwrite the current global memory data from a JSON payload.",
|
||||
)
|
||||
async def import_memory(
|
||||
request: MemoryResponse,
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemoryResponse:
|
||||
"""Import and persist memory data."""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
try:
|
||||
memory_data = import_memory_data(request.model_dump(), agent_name, user_id=get_effective_user_id())
|
||||
except OSError as exc:
|
||||
raise HTTPException(status_code=500, detail="Failed to import memory data.") from exc
|
||||
|
||||
return MemoryResponse(**memory_data)
|
||||
|
||||
|
||||
@router.get(
|
||||
"/memory/config",
|
||||
response_model=MemoryConfigResponse,
|
||||
summary="Get Memory Configuration",
|
||||
description="Retrieve the current memory system configuration.",
|
||||
)
|
||||
async def get_memory_config_endpoint() -> MemoryConfigResponse:
|
||||
"""Get the memory system configuration.
|
||||
|
||||
Returns:
|
||||
The current memory configuration settings.
|
||||
|
||||
Example Response:
|
||||
```json
|
||||
{
|
||||
"enabled": true,
|
||||
"storage_path": ".deer-flow/memory.json",
|
||||
"debounce_seconds": 30,
|
||||
"max_facts": 100,
|
||||
"fact_confidence_threshold": 0.7,
|
||||
"injection_enabled": true,
|
||||
"max_injection_tokens": 2000
|
||||
}
|
||||
```
|
||||
"""
|
||||
config = get_memory_config()
|
||||
return MemoryConfigResponse(
|
||||
enabled=config.enabled,
|
||||
storage_path=config.storage_path,
|
||||
debounce_seconds=config.debounce_seconds,
|
||||
max_facts=config.max_facts,
|
||||
fact_confidence_threshold=config.fact_confidence_threshold,
|
||||
injection_enabled=config.injection_enabled,
|
||||
max_injection_tokens=config.max_injection_tokens,
|
||||
)
|
||||
|
||||
|
||||
@router.get(
|
||||
"/memory/status",
|
||||
response_model=MemoryStatusResponse,
|
||||
response_model_exclude_none=True,
|
||||
summary="Get Memory Status",
|
||||
description="Retrieve both memory configuration and current data in a single request.",
|
||||
)
|
||||
async def get_memory_status(agent: str | None = _AgentQuery) -> MemoryStatusResponse:
|
||||
"""Get the memory system status including configuration and data.
|
||||
|
||||
Returns:
|
||||
Combined memory configuration and current data.
|
||||
"""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
config = get_memory_config()
|
||||
memory_data = get_memory_data(agent_name, user_id=get_effective_user_id())
|
||||
|
||||
return MemoryStatusResponse(
|
||||
config=MemoryConfigResponse(
|
||||
enabled=config.enabled,
|
||||
storage_path=config.storage_path,
|
||||
debounce_seconds=config.debounce_seconds,
|
||||
max_facts=config.max_facts,
|
||||
fact_confidence_threshold=config.fact_confidence_threshold,
|
||||
injection_enabled=config.injection_enabled,
|
||||
max_injection_tokens=config.max_injection_tokens,
|
||||
),
|
||||
data=MemoryResponse(**memory_data),
|
||||
)
|
||||
"""Memory V2 记忆 API 路由。
|
||||
|
||||
所有端点用 ``/api/memory/v2`` 前缀。Memory V2 重写后,旧的 facts/history
|
||||
端点 (``/api/memory``、``/memory/facts`` 等) 已移除。
|
||||
|
||||
端点:
|
||||
- ``GET /memory/v2`` 读取 builtin 本地记忆 (USER.md / MEMORY.md)
|
||||
- ``POST /memory/v2/entries`` 新增一条记忆条目
|
||||
- ``PUT /memory/v2/entries`` 替换一条记忆条目
|
||||
- ``DELETE /memory/v2/entries`` 删除一条记忆条目
|
||||
- ``GET /memory/v2/config`` 读取生效配置 + 用户可改字段白名单
|
||||
- ``PATCH /memory/v2/config`` 写入 per-user 配置覆盖 (白名单字段)
|
||||
- ``DELETE /memory/v2/config`` 撤销 per-user 配置覆盖
|
||||
- ``POST /memory/v2/search`` 代理 Hindsight 检索 (recall / reflect)
|
||||
|
||||
可选 ``agent`` 查询参数:省略或传 ``global`` 表示全局桶;传 agent 名表示该
|
||||
agent 的工作记忆桶。USER.md 始终是 per-user 全局的;MEMORY.md 按 agent 隔离。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from deerflow.config.agents_config import AGENT_NAME_PATTERN
|
||||
from deerflow.config.memory_config import (
|
||||
USER_WRITABLE_FIELDS,
|
||||
delete_user_memory_override,
|
||||
get_effective_memory_config,
|
||||
save_user_memory_override,
|
||||
)
|
||||
from deerflow.config.paths import get_paths
|
||||
from deerflow.runtime.user_context import get_effective_user_id
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["memory"])
|
||||
|
||||
|
||||
# 表示"全局桶 (无 agent)"的 agent 取值。
|
||||
_GLOBAL_AGENT_VALUES: frozenset[str] = frozenset({"", "global", "__global__"})
|
||||
|
||||
|
||||
def _resolve_agent_name(agent: str | None) -> str | None:
|
||||
"""校验 ``agent`` 查询参数,把全局哨兵规整为 ``None``。
|
||||
|
||||
返回 ``None`` 表示全局桶,否则返回小写的 agent 名。非法名抛 400。
|
||||
"""
|
||||
if agent is None:
|
||||
return None
|
||||
stripped = agent.strip()
|
||||
if stripped.lower() in _GLOBAL_AGENT_VALUES:
|
||||
return None
|
||||
if not AGENT_NAME_PATTERN.match(stripped):
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Invalid agent name {stripped!r}: must match {AGENT_NAME_PATTERN.pattern}",
|
||||
)
|
||||
return stripped.lower()
|
||||
|
||||
|
||||
_AgentQuery = Query(
|
||||
None,
|
||||
description="可选 agent 名。省略或传 'global' 表示全局桶;传 agent 名表示该 agent 的工作记忆桶。",
|
||||
examples=["my-agent"],
|
||||
pattern=r"^[A-Za-z0-9-]+$|^global$|^$",
|
||||
)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# 响应 / 请求模型
|
||||
# ===========================================================================
|
||||
|
||||
|
||||
class MemoryV2DataResponse(BaseModel):
|
||||
"""Memory V2 builtin provider 的数据视图。"""
|
||||
|
||||
user_entries: list[str] = Field(default_factory=list, description="USER.md 条目 (用户画像)")
|
||||
memory_entries: list[str] = Field(default_factory=list, description="MEMORY.md 条目 (agent 工作笔记)")
|
||||
user_usage: str = Field(default="", description="USER.md 字符用量,如 '12% — 165/1375 字符'")
|
||||
memory_usage: str = Field(default="", description="MEMORY.md 字符用量")
|
||||
|
||||
|
||||
class MemoryV2ConfigResponse(BaseModel):
|
||||
"""Memory V2 生效配置 (含三层覆盖合并结果) + 用户可改字段白名单。"""
|
||||
|
||||
config: dict[str, Any] = Field(..., description="按 per-user 覆盖合并后的生效配置")
|
||||
writable_fields: list[str] = Field(..., description="用户可在运行时覆盖的字段 (点号路径)")
|
||||
|
||||
|
||||
class MemoryConfigPatchRequest(BaseModel):
|
||||
"""Memory V2 配置覆盖请求。
|
||||
|
||||
overrides 支持嵌套形式 ``{"injection": {"enabled": false}}`` 或点号扁平形式
|
||||
``{"injection.enabled": false}``;非白名单字段会被忽略。
|
||||
"""
|
||||
|
||||
overrides: dict[str, Any] = Field(..., description="要写入 per-user 覆盖的字段")
|
||||
|
||||
|
||||
class MemoryEntryCreateRequest(BaseModel):
|
||||
"""新增一条 V2 记忆条目。"""
|
||||
|
||||
target: str = Field(..., description="memory(工作笔记) 或 user(用户画像)")
|
||||
content: str = Field(..., min_length=1, description="条目内容")
|
||||
|
||||
|
||||
class MemoryEntryReplaceRequest(BaseModel):
|
||||
"""替换一条 V2 记忆条目。"""
|
||||
|
||||
target: str = Field(..., description="memory 或 user")
|
||||
old_text: str = Field(..., min_length=1, description="短唯一子串,定位要替换的条目")
|
||||
content: str = Field(..., min_length=1, description="新内容")
|
||||
|
||||
|
||||
class MemorySearchRequest(BaseModel):
|
||||
"""Hindsight 检索请求。"""
|
||||
|
||||
query: str = Field(..., min_length=1, description="检索查询")
|
||||
mode: str = Field(default="recall", description="recall(返回原始片段) 或 reflect(LLM 综合)")
|
||||
|
||||
|
||||
class MemorySearchResponse(BaseModel):
|
||||
"""Hindsight 检索结果。"""
|
||||
|
||||
available: bool = Field(..., description="Hindsight 是否可用 (未配置/未装包时为 false)")
|
||||
results: list[str] = Field(default_factory=list, description="recall 模式的检索结果")
|
||||
text: str = Field(default="", description="reflect 模式的综合结论")
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# 辅助函数
|
||||
# ===========================================================================
|
||||
|
||||
|
||||
def _build_builtin_provider(user_id: str, agent_name: str | None):
|
||||
"""按生效配置构建并初始化一个 V2 builtin provider。"""
|
||||
from deerflow.agents.memory.providers.builtin import BuiltinFileProvider
|
||||
|
||||
config = get_effective_memory_config(user_id)
|
||||
provider = BuiltinFileProvider(
|
||||
memory_char_limit=config.builtin.memory_char_limit,
|
||||
user_char_limit=config.builtin.user_char_limit,
|
||||
deduplicate_on_load=config.builtin.deduplicate_on_load,
|
||||
security=config.security,
|
||||
)
|
||||
provider.initialize(
|
||||
user_id=user_id,
|
||||
agent_id=agent_name or "default",
|
||||
base_dir=str(get_paths().base_dir),
|
||||
)
|
||||
return provider
|
||||
|
||||
|
||||
def _validate_v2_target(target: str) -> str:
|
||||
"""校验 V2 entries 的 target,非法时抛 400。"""
|
||||
if target not in ("memory", "user"):
|
||||
raise HTTPException(status_code=400, detail=f"非法 target '{target}',只能是 'memory' 或 'user'。")
|
||||
return target
|
||||
|
||||
|
||||
def _v2_data_response(provider) -> MemoryV2DataResponse:
|
||||
"""从 builtin provider 读出当前数据,组装成 MemoryV2DataResponse。"""
|
||||
return MemoryV2DataResponse(
|
||||
user_entries=provider.read("user"),
|
||||
memory_entries=provider.read("memory"),
|
||||
user_usage=provider.usage("user"),
|
||||
memory_usage=provider.usage("memory"),
|
||||
)
|
||||
|
||||
|
||||
def _raise_if_write_failed(result: dict) -> None:
|
||||
"""builtin provider 写操作失败时抛 400。"""
|
||||
if not result.get("success"):
|
||||
raise HTTPException(status_code=400, detail=result.get("error", "记忆写入失败。"))
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# 数据端点
|
||||
# ===========================================================================
|
||||
|
||||
|
||||
@router.get(
|
||||
"/memory/v2",
|
||||
response_model=MemoryV2DataResponse,
|
||||
summary="Get Memory V2 Data",
|
||||
description="读取 Memory V2 builtin provider 的 USER.md / MEMORY.md 条目。",
|
||||
)
|
||||
async def get_memory_v2(agent: str | None = _AgentQuery) -> MemoryV2DataResponse:
|
||||
"""读取当前用户的 Memory V2 本地记忆。"""
|
||||
agent_name = _resolve_agent_name(agent)
|
||||
user_id = get_effective_user_id()
|
||||
try:
|
||||
provider = _build_builtin_provider(user_id, agent_name)
|
||||
return _v2_data_response(provider)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
raise HTTPException(status_code=500, detail="Failed to read memory V2 data.") from exc
|
||||
|
||||
|
||||
@router.post(
|
||||
"/memory/v2/entries",
|
||||
response_model=MemoryV2DataResponse,
|
||||
summary="Add Memory V2 Entry",
|
||||
description="手动往 USER.md / MEMORY.md 新增一条记忆条目。",
|
||||
)
|
||||
async def add_memory_v2_entry(
|
||||
request: MemoryEntryCreateRequest,
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemoryV2DataResponse:
|
||||
"""手动新增一条 V2 记忆条目。"""
|
||||
_validate_v2_target(request.target)
|
||||
user_id = get_effective_user_id()
|
||||
try:
|
||||
provider = _build_builtin_provider(user_id, _resolve_agent_name(agent))
|
||||
result = provider.add(request.target, request.content)
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as exc: # noqa: BLE001
|
||||
raise HTTPException(status_code=500, detail="Failed to add memory entry.") from exc
|
||||
_raise_if_write_failed(result)
|
||||
return _v2_data_response(provider)
|
||||
|
||||
|
||||
@router.put(
|
||||
"/memory/v2/entries",
|
||||
response_model=MemoryV2DataResponse,
|
||||
summary="Replace Memory V2 Entry",
|
||||
description="用 old_text 定位一条记忆条目并替换为新内容。",
|
||||
)
|
||||
async def replace_memory_v2_entry(
|
||||
request: MemoryEntryReplaceRequest,
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemoryV2DataResponse:
|
||||
"""手动替换一条 V2 记忆条目。"""
|
||||
_validate_v2_target(request.target)
|
||||
user_id = get_effective_user_id()
|
||||
try:
|
||||
provider = _build_builtin_provider(user_id, _resolve_agent_name(agent))
|
||||
result = provider.replace(request.target, request.old_text, request.content)
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as exc: # noqa: BLE001
|
||||
raise HTTPException(status_code=500, detail="Failed to replace memory entry.") from exc
|
||||
_raise_if_write_failed(result)
|
||||
return _v2_data_response(provider)
|
||||
|
||||
|
||||
@router.delete(
|
||||
"/memory/v2/entries",
|
||||
response_model=MemoryV2DataResponse,
|
||||
summary="Delete Memory V2 Entry",
|
||||
description="用 old_text 定位并删除一条记忆条目。",
|
||||
)
|
||||
async def delete_memory_v2_entry(
|
||||
target: str = Query(..., description="memory 或 user"),
|
||||
old_text: str = Query(..., min_length=1, description="短唯一子串,定位要删除的条目"),
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemoryV2DataResponse:
|
||||
"""手动删除一条 V2 记忆条目。"""
|
||||
_validate_v2_target(target)
|
||||
user_id = get_effective_user_id()
|
||||
try:
|
||||
provider = _build_builtin_provider(user_id, _resolve_agent_name(agent))
|
||||
result = provider.remove(target, old_text)
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as exc: # noqa: BLE001
|
||||
raise HTTPException(status_code=500, detail="Failed to delete memory entry.") from exc
|
||||
_raise_if_write_failed(result)
|
||||
return _v2_data_response(provider)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# 配置端点
|
||||
# ===========================================================================
|
||||
|
||||
|
||||
@router.get(
|
||||
"/memory/v2/config",
|
||||
response_model=MemoryV2ConfigResponse,
|
||||
summary="Get Memory V2 Effective Config",
|
||||
description="读取按 per-user 覆盖合并后的生效记忆配置,以及用户可改字段白名单。",
|
||||
)
|
||||
async def get_memory_v2_config() -> MemoryV2ConfigResponse:
|
||||
"""读取当前用户的生效记忆配置。"""
|
||||
user_id = get_effective_user_id()
|
||||
config = get_effective_memory_config(user_id)
|
||||
return MemoryV2ConfigResponse(
|
||||
config=config.model_dump(),
|
||||
writable_fields=sorted(USER_WRITABLE_FIELDS),
|
||||
)
|
||||
|
||||
|
||||
@router.patch(
|
||||
"/memory/v2/config",
|
||||
response_model=MemoryV2ConfigResponse,
|
||||
summary="Patch Memory V2 Config",
|
||||
description="把白名单字段写入当前用户的 per-user 配置覆盖。非白名单字段被忽略。",
|
||||
)
|
||||
async def patch_memory_v2_config(request: MemoryConfigPatchRequest) -> MemoryV2ConfigResponse:
|
||||
"""更新当前用户的 per-user 记忆配置覆盖。"""
|
||||
user_id = get_effective_user_id()
|
||||
try:
|
||||
save_user_memory_override(user_id, request.overrides)
|
||||
except OSError as exc:
|
||||
raise HTTPException(status_code=500, detail="Failed to save memory config override.") from exc
|
||||
|
||||
config = get_effective_memory_config(user_id)
|
||||
return MemoryV2ConfigResponse(
|
||||
config=config.model_dump(),
|
||||
writable_fields=sorted(USER_WRITABLE_FIELDS),
|
||||
)
|
||||
|
||||
|
||||
@router.delete(
|
||||
"/memory/v2/config",
|
||||
response_model=MemoryV2ConfigResponse,
|
||||
summary="Delete Memory V2 Config Override",
|
||||
description=(
|
||||
"撤销当前用户的 per-user 配置覆盖。传 ?field=injection.enabled 只撤销该字段;"
|
||||
"不传 field 则清空整个 per-user 覆盖。"
|
||||
),
|
||||
)
|
||||
async def delete_memory_v2_config(
|
||||
field: str | None = Query(None, description="要撤销的点号路径字段;省略则清空全部覆盖"),
|
||||
) -> MemoryV2ConfigResponse:
|
||||
"""撤销当前用户的 per-user 记忆配置覆盖。"""
|
||||
user_id = get_effective_user_id()
|
||||
try:
|
||||
delete_user_memory_override(user_id, field)
|
||||
except OSError as exc:
|
||||
raise HTTPException(status_code=500, detail="Failed to delete memory config override.") from exc
|
||||
|
||||
config = get_effective_memory_config(user_id)
|
||||
return MemoryV2ConfigResponse(
|
||||
config=config.model_dump(),
|
||||
writable_fields=sorted(USER_WRITABLE_FIELDS),
|
||||
)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# Hindsight 检索代理端点
|
||||
# ===========================================================================
|
||||
|
||||
|
||||
@router.post(
|
||||
"/memory/v2/search",
|
||||
response_model=MemorySearchResponse,
|
||||
summary="Search Hindsight Memory",
|
||||
description=(
|
||||
"代理 Hindsight 检索。mode=recall 返回原始记忆片段;mode=reflect 返回 LLM 综合结论。"
|
||||
"Hindsight 未配置或不可用时返回 available=false。"
|
||||
),
|
||||
)
|
||||
async def search_memory_v2(
|
||||
request: MemorySearchRequest,
|
||||
agent: str | None = _AgentQuery,
|
||||
) -> MemorySearchResponse:
|
||||
"""代理 Hindsight 检索 (recall / reflect)。"""
|
||||
user_id = get_effective_user_id()
|
||||
config = get_effective_memory_config(user_id)
|
||||
if not config.enabled or config.provider != "hindsight":
|
||||
return MemorySearchResponse(available=False)
|
||||
|
||||
try:
|
||||
from deerflow.agents.memory.providers.hindsight import HindsightProvider
|
||||
|
||||
provider = HindsightProvider(config.hindsight)
|
||||
if not provider.is_available():
|
||||
return MemorySearchResponse(available=False)
|
||||
provider.initialize(
|
||||
user_id=user_id,
|
||||
agent_id=_resolve_agent_name(agent) or "default",
|
||||
thread_id="",
|
||||
base_dir="",
|
||||
)
|
||||
if request.mode == "reflect":
|
||||
text = provider.reflect(request.query)
|
||||
return MemorySearchResponse(available=True, text=text)
|
||||
results = provider.recall(request.query)
|
||||
return MemorySearchResponse(available=True, results=results)
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as exc: # noqa: BLE001
|
||||
raise HTTPException(status_code=500, detail="Failed to search Hindsight memory.") from exc
|
||||
@@ -197,7 +197,7 @@ async def get_scheduler_thread(request: Request) -> dict:
|
||||
async def list_scheduled_tasks(
|
||||
request: Request,
|
||||
search: str | None = Query(default=None, description="Case-insensitive fuzzy match on task name"),
|
||||
tag_id: str | None = Query(default=None, description="Keep only tasks carrying this tag"),
|
||||
tag_ids: list[str] | None = Query(default=None, description="Keep tasks carrying any of these tags (OR)"),
|
||||
) -> list[dict]:
|
||||
service = get_scheduled_task_service()
|
||||
user_id = await _user_id(request)
|
||||
@@ -211,8 +211,9 @@ async def list_scheduled_tasks(
|
||||
if search:
|
||||
needle = search.strip().lower()
|
||||
tasks = [t for t in tasks if needle in str(t.get("name", "")).lower()]
|
||||
if tag_id:
|
||||
tasks = [t for t in tasks if any(tg.get("id") == tag_id for tg in t.get("tags", []))]
|
||||
if tag_ids:
|
||||
wanted = set(tag_ids)
|
||||
tasks = [t for t in tasks if any(tg.get("id") in wanted for tg in t.get("tags", []))]
|
||||
return tasks
|
||||
|
||||
|
||||
|
||||
@@ -236,7 +236,7 @@ async def _attach_and_filter_tags(
|
||||
tag_store: TagStore,
|
||||
responses: list[SkillResponse],
|
||||
search: str | None,
|
||||
tag_id: str | None,
|
||||
tag_ids: list[str] | None,
|
||||
) -> list[SkillResponse]:
|
||||
"""Bulk-attach tags to skill responses, then apply name/tag filters."""
|
||||
assignments = await tag_store.list_assignments("skill", [r.name for r in responses])
|
||||
@@ -245,8 +245,9 @@ async def _attach_and_filter_tags(
|
||||
if search:
|
||||
needle = search.strip().lower()
|
||||
responses = [r for r in responses if needle in r.name.lower()]
|
||||
if tag_id:
|
||||
responses = [r for r in responses if any(t.get("id") == tag_id for t in r.tags)]
|
||||
if tag_ids:
|
||||
wanted = set(tag_ids)
|
||||
responses = [r for r in responses if any(t.get("id") in wanted for t in r.tags)]
|
||||
return responses
|
||||
|
||||
|
||||
@@ -262,7 +263,7 @@ async def list_skills(
|
||||
skill_store: SkillStore = Depends(get_skill_store),
|
||||
tag_store: TagStore = Depends(get_tag_store),
|
||||
search: str | None = Query(default=None, description="Case-insensitive fuzzy match on skill name"),
|
||||
tag_id: str | None = Query(default=None, description="Keep only skills carrying this tag"),
|
||||
tag_ids: list[str] | None = Query(default=None, description="Keep skills carrying any of these tags (OR)"),
|
||||
) -> SkillsListResponse:
|
||||
try:
|
||||
user_id = _current_user_id(request)
|
||||
@@ -281,7 +282,7 @@ async def list_skills(
|
||||
if record is None:
|
||||
continue
|
||||
responses.append(_skill_to_response(skill, record))
|
||||
responses = await _attach_and_filter_tags(tag_store, responses, search, tag_id)
|
||||
responses = await _attach_and_filter_tags(tag_store, responses, search, tag_ids)
|
||||
return SkillsListResponse(skills=responses)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to load skills: {e}", exc_info=True)
|
||||
|
||||
@@ -294,20 +294,38 @@ async def get_public_share_snapshot(
|
||||
)
|
||||
|
||||
|
||||
# Content types that can execute scripts in the app origin — always served as
|
||||
# a download attachment so a shared file can never run as a top-level document.
|
||||
_PUBLIC_SHARE_ACTIVE_TYPES = {"text/html", "application/xhtml+xml", "image/svg+xml"}
|
||||
|
||||
|
||||
def _public_share_disposition(mime_type: str) -> str:
|
||||
"""Pick a Content-Disposition for a public-share file.
|
||||
|
||||
Active content (HTML/XHTML/SVG) is forced to ``attachment`` so it cannot
|
||||
execute as a top-level document; everything else (images, Markdown, text,
|
||||
PDF, …) is served ``inline`` so viewers can open it directly.
|
||||
"""
|
||||
return "attachment" if mime_type in _PUBLIC_SHARE_ACTIVE_TYPES else "inline"
|
||||
|
||||
|
||||
@public_router.get(
|
||||
"/{share_code}/files/{path:path}",
|
||||
summary="Public image attachment from a view-shared conversation",
|
||||
summary="Public file attachment from a view-shared conversation",
|
||||
)
|
||||
async def get_public_share_file(
|
||||
share_code: str,
|
||||
path: str,
|
||||
share_store: ThreadShareStore = Depends(get_thread_share_store),
|
||||
) -> FileResponse:
|
||||
"""Serve an image referenced by a view-shared conversation.
|
||||
"""Serve a file referenced by a view-shared conversation.
|
||||
|
||||
Restricted to images only — the public share page renders inline images,
|
||||
but the endpoint must not become a way to read arbitrary thread files.
|
||||
Non-image paths return 404 just like a missing file.
|
||||
A ``view`` share is a public read-only page, so the files its conversation
|
||||
references (images, Markdown, text, PDF, …) must be openable. Path
|
||||
resolution is confined to the owner's thread directory, so this cannot read
|
||||
arbitrary files. Active content (HTML/XHTML/SVG) is forced to download so it
|
||||
can never execute as a top-level document in the app origin; everything
|
||||
else is served inline.
|
||||
"""
|
||||
share = await share_store.get(share_code)
|
||||
if share is None or share.get("revoked") or share.get("mode") != "view":
|
||||
@@ -324,17 +342,10 @@ async def get_public_share_file(
|
||||
if not actual_path.exists() or not actual_path.is_file():
|
||||
raise HTTPException(status_code=404, detail="File not found")
|
||||
|
||||
mime_type, _ = mimetypes.guess_type(actual_path.name)
|
||||
if not mime_type or not mime_type.startswith("image/"):
|
||||
# Only images are public; everything else is treated as not found.
|
||||
raise HTTPException(status_code=404, detail="File not found")
|
||||
|
||||
# SVG can carry scripts — serve it as a download so it can never execute
|
||||
# as a top-level document in the app origin. Raster images render inline.
|
||||
is_svg = mime_type == "image/svg+xml"
|
||||
mime_type = mimetypes.guess_type(actual_path.name)[0] or "application/octet-stream"
|
||||
return FileResponse(
|
||||
actual_path,
|
||||
media_type=mime_type,
|
||||
content_disposition_type="attachment" if is_svg else "inline",
|
||||
content_disposition_type=_public_share_disposition(mime_type),
|
||||
headers={"Cache-Control": "public, max-age=300"},
|
||||
)
|
||||
@@ -0,0 +1,380 @@
|
||||
"""Admin-only tool / skill call metrics: list + Excel export.
|
||||
|
||||
Companion to ``llm_metrics`` — where that audits every LLM provider call, this
|
||||
audits every *tool* call (built-in tools, skills, MCP tools, subagent calls),
|
||||
including the failures: retrieval errors, blocked/rate-limited IPs, timeouts,
|
||||
auth problems. Failures are bucketed into a coarse ``error_category`` so an
|
||||
admin can scan for systemic issues.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from datetime import datetime
|
||||
from io import BytesIO
|
||||
from typing import Any
|
||||
from urllib.parse import quote
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query, Request
|
||||
from fastapi.responses import StreamingResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.gateway.deps import get_local_provider, get_optional_user_from_request, get_tool_metrics_store
|
||||
from deerflow.persistence.tool_metrics.base import ToolMetricsQuery, ToolMetricsStore
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
router = APIRouter(prefix="/api/admin/tool-metrics", tags=["tool-metrics"])
|
||||
|
||||
_VALID_CATEGORIES = (
|
||||
"rate_limited",
|
||||
"ip_blocked",
|
||||
"auth_error",
|
||||
"timeout",
|
||||
"network_error",
|
||||
"not_found",
|
||||
"empty_result",
|
||||
"tool_error",
|
||||
)
|
||||
|
||||
def _kind_is_skill(kind: str | None) -> bool:
|
||||
"""``kind=skill`` keeps only rows that target a specific Agent Skill."""
|
||||
return kind == "skill"
|
||||
|
||||
|
||||
class ToolMetricResponse(BaseModel):
|
||||
id: str
|
||||
created_at: str | None = None
|
||||
user_id: str | None = None
|
||||
user_name: str | None = Field(
|
||||
default=None,
|
||||
description="Local part (before @) of the user's email, resolved from user_id",
|
||||
)
|
||||
thread_id: str | None = None
|
||||
run_id: str | None = None
|
||||
agent_name: str | None = None
|
||||
tool_name: str | None = None
|
||||
skill_name: str | None = Field(
|
||||
default=None,
|
||||
description="The Agent Skill this call targets (skill tools only)",
|
||||
)
|
||||
duration_ms: int = 0
|
||||
status: str = "success"
|
||||
error_category: str | None = None
|
||||
error_message: str | None = None
|
||||
|
||||
|
||||
class ToolMetricsListResponse(BaseModel):
|
||||
items: list[ToolMetricResponse]
|
||||
total: int = Field(..., description="Total rows matching the filter, ignoring pagination")
|
||||
limit: int
|
||||
offset: int
|
||||
|
||||
|
||||
async def _require_admin(request: Request) -> None:
|
||||
user = await get_optional_user_from_request(request)
|
||||
if user is None:
|
||||
return
|
||||
if getattr(user, "system_role", None) != "admin":
|
||||
raise HTTPException(status_code=403, detail="Tool metrics admin view is admin-only")
|
||||
|
||||
|
||||
def _require_store(request: Request) -> ToolMetricsStore:
|
||||
store = get_tool_metrics_store(request)
|
||||
if store is None:
|
||||
raise HTTPException(status_code=503, detail="Tool metrics store is not configured")
|
||||
return store
|
||||
|
||||
|
||||
def _parse_dt(value: str | None) -> datetime | None:
|
||||
if not value:
|
||||
return None
|
||||
try:
|
||||
return datetime.fromisoformat(value.replace("Z", "+00:00"))
|
||||
except ValueError as exc:
|
||||
raise HTTPException(status_code=422, detail=f"Invalid datetime: {value!r} ({exc})") from exc
|
||||
|
||||
|
||||
def _email_local_part(email: str | None) -> str | None:
|
||||
if not email:
|
||||
return None
|
||||
at = email.find("@")
|
||||
return email[:at] if at > 0 else email
|
||||
|
||||
|
||||
async def _resolve_user_name_to_id(name: str | None) -> str | None:
|
||||
if not name:
|
||||
return None
|
||||
try:
|
||||
provider = get_local_provider()
|
||||
user = await provider.find_user_by_email_local_part(name)
|
||||
except Exception:
|
||||
return None
|
||||
return str(user.id) if user is not None else None
|
||||
|
||||
|
||||
async def _attach_usernames(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
"""Resolve each row's ``user_id`` UUID to a friendly ``user_name``."""
|
||||
if not rows:
|
||||
return rows
|
||||
user_ids = {row["user_id"] for row in rows if isinstance(row, dict) and row.get("user_id")}
|
||||
if not user_ids:
|
||||
return rows
|
||||
try:
|
||||
provider = get_local_provider()
|
||||
except Exception:
|
||||
provider = None
|
||||
email_by_id: dict[str, str] = {}
|
||||
if provider is not None:
|
||||
for uid in user_ids:
|
||||
try:
|
||||
user = await provider.get_user(uid)
|
||||
except Exception:
|
||||
user = None
|
||||
if user is not None and user.email:
|
||||
email_by_id[uid] = user.email
|
||||
for row in rows:
|
||||
if isinstance(row, dict) and row.get("user_id"):
|
||||
email = email_by_id.get(row["user_id"])
|
||||
row["user_name"] = _email_local_part(email) or row["user_id"]
|
||||
return rows
|
||||
|
||||
|
||||
def _build_query(
|
||||
*,
|
||||
user_id: str | None,
|
||||
tool_name: str | None,
|
||||
skill_only: bool = False,
|
||||
skill_name: str | None = None,
|
||||
status: str | None,
|
||||
error_category: str | None,
|
||||
since: str | None,
|
||||
until: str | None,
|
||||
limit: int,
|
||||
offset: int,
|
||||
) -> ToolMetricsQuery:
|
||||
return ToolMetricsQuery(
|
||||
user_id=user_id or None,
|
||||
tool_name=tool_name or None,
|
||||
skill_only=skill_only,
|
||||
skill_name=skill_name or None,
|
||||
status=status or None,
|
||||
error_category=error_category or None,
|
||||
since=_parse_dt(since),
|
||||
until=_parse_dt(until),
|
||||
limit=limit,
|
||||
offset=offset,
|
||||
)
|
||||
|
||||
|
||||
@router.get("", response_model=ToolMetricsListResponse)
|
||||
async def list_tool_metrics(
|
||||
request: Request,
|
||||
user_id: str | None = Query(default=None),
|
||||
user_name: str | None = Query(default=None, description="Username (email local part) to filter by"),
|
||||
tool_name: str | None = Query(default=None),
|
||||
kind: str | None = Query(default=None, description="Coarse call kind: 'skill' keeps only Agent-Skill invocations"),
|
||||
skill_name: str | None = Query(default=None, description="Filter to one specific Agent Skill by name"),
|
||||
status: str | None = Query(default=None, pattern="^(success|error)$"),
|
||||
error_category: str | None = Query(default=None, description="Coarse failure bucket"),
|
||||
since: str | None = Query(default=None, description="ISO 8601 datetime, inclusive lower bound"),
|
||||
until: str | None = Query(default=None, description="ISO 8601 datetime, inclusive upper bound"),
|
||||
limit: int = Query(default=50, ge=1, le=500),
|
||||
offset: int = Query(default=0, ge=0),
|
||||
) -> ToolMetricsListResponse:
|
||||
await _require_admin(request)
|
||||
store = _require_store(request)
|
||||
if error_category and error_category not in _VALID_CATEGORIES:
|
||||
raise HTTPException(status_code=422, detail=f"Unknown error_category: {error_category!r}")
|
||||
if not user_id and user_name:
|
||||
resolved = await _resolve_user_name_to_id(user_name)
|
||||
if resolved is None:
|
||||
return ToolMetricsListResponse(items=[], total=0, limit=limit, offset=offset)
|
||||
user_id = resolved
|
||||
query = _build_query(
|
||||
user_id=user_id,
|
||||
tool_name=tool_name,
|
||||
skill_only=_kind_is_skill(kind),
|
||||
skill_name=skill_name,
|
||||
status=status,
|
||||
error_category=error_category,
|
||||
since=since,
|
||||
until=until,
|
||||
limit=limit,
|
||||
offset=offset,
|
||||
)
|
||||
rows = await store.list(query)
|
||||
total = await store.count(query)
|
||||
await _attach_usernames(rows)
|
||||
return ToolMetricsListResponse(
|
||||
items=[ToolMetricResponse(**row) for row in rows],
|
||||
total=total,
|
||||
limit=limit,
|
||||
offset=offset,
|
||||
)
|
||||
|
||||
|
||||
class SkillStat(BaseModel):
|
||||
skill_name: str
|
||||
total: int
|
||||
success: int
|
||||
error: int
|
||||
|
||||
|
||||
class ToolMetricsSummaryResponse(BaseModel):
|
||||
total: int
|
||||
error_total: int
|
||||
by_category: dict[str, int] = Field(default_factory=dict)
|
||||
by_skill: list[SkillStat] = Field(
|
||||
default_factory=list,
|
||||
description="Per-skill invocation counts — answers 'was skill X called, and did it succeed'",
|
||||
)
|
||||
|
||||
|
||||
@router.get("/summary", response_model=ToolMetricsSummaryResponse)
|
||||
async def tool_metrics_summary(
|
||||
request: Request,
|
||||
user_id: str | None = Query(default=None),
|
||||
user_name: str | None = Query(default=None),
|
||||
tool_name: str | None = Query(default=None),
|
||||
kind: str | None = Query(default=None),
|
||||
skill_name: str | None = Query(default=None),
|
||||
since: str | None = Query(default=None),
|
||||
until: str | None = Query(default=None),
|
||||
) -> ToolMetricsSummaryResponse:
|
||||
"""Aggregate counts: total, errors, per-category breakdown, and per-skill stats."""
|
||||
await _require_admin(request)
|
||||
store = _require_store(request)
|
||||
if not user_id and user_name:
|
||||
resolved = await _resolve_user_name_to_id(user_name)
|
||||
if resolved is None:
|
||||
return ToolMetricsSummaryResponse(total=0, error_total=0, by_category={}, by_skill=[])
|
||||
user_id = resolved
|
||||
skill_only = _kind_is_skill(kind)
|
||||
|
||||
def _q(*, status: str | None = None, error_category: str | None = None) -> ToolMetricsQuery:
|
||||
return _build_query(
|
||||
user_id=user_id,
|
||||
tool_name=tool_name,
|
||||
skill_only=skill_only,
|
||||
skill_name=skill_name,
|
||||
status=status,
|
||||
error_category=error_category,
|
||||
since=since,
|
||||
until=until,
|
||||
limit=1,
|
||||
offset=0,
|
||||
)
|
||||
|
||||
total = await store.count(_q())
|
||||
error_total = await store.count(_q(status="error"))
|
||||
by_category: dict[str, int] = {}
|
||||
for category in _VALID_CATEGORIES:
|
||||
count = await store.count(_q(status="error", error_category=category))
|
||||
if count:
|
||||
by_category[category] = count
|
||||
by_skill = [SkillStat(**row) for row in await store.skill_breakdown(_q())]
|
||||
return ToolMetricsSummaryResponse(
|
||||
total=total, error_total=error_total, by_category=by_category, by_skill=by_skill
|
||||
)
|
||||
|
||||
|
||||
def _format_cell(value: Any) -> Any:
|
||||
if value is None:
|
||||
return ""
|
||||
if isinstance(value, datetime):
|
||||
return value.replace(tzinfo=None) if value.tzinfo else value
|
||||
return value
|
||||
|
||||
|
||||
@router.get("/export")
|
||||
async def export_tool_metrics(
|
||||
request: Request,
|
||||
user_id: str | None = Query(default=None),
|
||||
user_name: str | None = Query(default=None),
|
||||
tool_name: str | None = Query(default=None),
|
||||
kind: str | None = Query(default=None),
|
||||
skill_name: str | None = Query(default=None),
|
||||
status: str | None = Query(default=None, pattern="^(success|error)$"),
|
||||
error_category: str | None = Query(default=None),
|
||||
since: str | None = Query(default=None),
|
||||
until: str | None = Query(default=None),
|
||||
):
|
||||
"""Stream the full filtered metric set as an ``.xlsx`` file."""
|
||||
await _require_admin(request)
|
||||
store = _require_store(request)
|
||||
if not user_id and user_name:
|
||||
resolved = await _resolve_user_name_to_id(user_name)
|
||||
user_id = resolved if resolved is not None else "__no_such_user__"
|
||||
|
||||
try:
|
||||
from openpyxl import Workbook
|
||||
except ImportError as exc:
|
||||
raise HTTPException(status_code=500, detail=f"openpyxl is not installed: {exc}") from exc
|
||||
|
||||
query = _build_query(
|
||||
user_id=user_id,
|
||||
tool_name=tool_name,
|
||||
skill_only=_kind_is_skill(kind),
|
||||
skill_name=skill_name,
|
||||
status=status,
|
||||
error_category=error_category,
|
||||
since=since,
|
||||
until=until,
|
||||
limit=1,
|
||||
offset=0,
|
||||
)
|
||||
|
||||
workbook = Workbook(write_only=True)
|
||||
sheet = workbook.create_sheet("tool_call_metrics")
|
||||
columns = [
|
||||
"id",
|
||||
"created_at",
|
||||
"status",
|
||||
"error_category",
|
||||
"user_name",
|
||||
"user_id",
|
||||
"thread_id",
|
||||
"run_id",
|
||||
"agent_name",
|
||||
"tool_name",
|
||||
"skill_name",
|
||||
"duration_ms",
|
||||
"error_message",
|
||||
]
|
||||
sheet.append(columns)
|
||||
|
||||
buffered: list[dict[str, Any]] = []
|
||||
FLUSH_AT = 200
|
||||
|
||||
async def flush() -> int:
|
||||
if not buffered:
|
||||
return 0
|
||||
await _attach_usernames(buffered)
|
||||
for row in buffered:
|
||||
sheet.append([_format_cell(row.get(col)) for col in columns])
|
||||
n = len(buffered)
|
||||
buffered.clear()
|
||||
return n
|
||||
|
||||
count = 0
|
||||
async for row in store.iter_all(query):
|
||||
buffered.append(row)
|
||||
if len(buffered) >= FLUSH_AT:
|
||||
count += await flush()
|
||||
count += await flush()
|
||||
|
||||
buffer = BytesIO()
|
||||
workbook.save(buffer)
|
||||
buffer.seek(0)
|
||||
logger.info("Exported %d tool_call_metrics rows", count)
|
||||
|
||||
timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
|
||||
filename = f"tool_call_metrics-{timestamp}.xlsx"
|
||||
headers = {
|
||||
"Content-Disposition": f"attachment; filename=\"{filename}\"; filename*=UTF-8''{quote(filename)}",
|
||||
}
|
||||
return StreamingResponse(
|
||||
buffer,
|
||||
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
||||
headers=headers,
|
||||
)
|
||||
Reference in new issue
Block a user