sync snapshot from LAN repo (source codex/merge-tjlnew-classic-retrieval-20261019 @ ded012d9)
This commit is contained in:
1 parent
ea9dcff9c0
commit
c753e6c9b5
818 files changed
+14037
-108991
No files matched your search
@@ -8,34 +8,18 @@ import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import zipfile
|
||||
from datetime import UTC, datetime
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, Depends, File, HTTPException, Query, Request, Response, UploadFile
|
||||
from fastapi import APIRouter, Body, Depends, File, HTTPException, Query, Request, UploadFile
|
||||
from fastapi.responses import FileResponse
|
||||
from pydantic import BaseModel, Field
|
||||
from sqlalchemy import select
|
||||
|
||||
from app.gateway.api_read_cache import (
|
||||
get_cache_version,
|
||||
get_cached_json_payload,
|
||||
release_cache_fill,
|
||||
set_cached_json,
|
||||
wait_for_cached_json_payload_or_claim_fill,
|
||||
)
|
||||
from app.gateway.deps import get_agent_store, get_config, get_skill_store, get_tag_store
|
||||
from app.gateway.path_utils import aresolve_thread_virtual_path
|
||||
from app.gateway.perf_logging import finish_trace, trace_request, trace_stage
|
||||
from app.gateway.skill_catalog_cache import (
|
||||
_build_catalog_payload,
|
||||
_load_usage_entries,
|
||||
load_or_warm_skill_catalog_snapshot,
|
||||
load_skill_catalog_projection,
|
||||
refresh_skill_catalog_projection,
|
||||
)
|
||||
from deerflow.agents.lead_agent.prompt import refresh_skills_system_prompt_cache_async
|
||||
from deerflow.config.app_config import AppConfig
|
||||
from deerflow.config.extensions_config import ExtensionsConfig, SkillDisplayConfig, get_extensions_config, patch_extensions_config
|
||||
@@ -55,9 +39,6 @@ logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["skills"])
|
||||
_UNSET = object()
|
||||
_OWNER_USERNAME_CACHE_SECONDS = 60.0
|
||||
_MAX_OWNER_USERNAME_CACHE_ENTRIES = 4096
|
||||
_owner_username_cache: dict[str, tuple[float, str | None]] = {}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
@@ -100,59 +81,21 @@ async def _attach_owner_usernames(responses: list["SkillResponse"]) -> list["Ski
|
||||
provider = get_local_provider()
|
||||
except Exception:
|
||||
return responses
|
||||
now = time.monotonic()
|
||||
names: dict[str, str] = {}
|
||||
missing_ids: set[str] = set()
|
||||
for user_id in owner_ids:
|
||||
cached = _owner_username_cache.get(user_id)
|
||||
if cached is not None and cached[0] > now:
|
||||
if cached[1]:
|
||||
names[user_id] = cached[1]
|
||||
else:
|
||||
missing_ids.add(user_id)
|
||||
|
||||
if missing_ids:
|
||||
for uid in owner_ids:
|
||||
try:
|
||||
users = await provider.get_users_by_ids(sorted(missing_ids))
|
||||
user = await provider.get_user(uid)
|
||||
except Exception:
|
||||
logger.debug("skill owner username batch lookup failed", exc_info=True)
|
||||
users = None
|
||||
if users is not None:
|
||||
loaded = {
|
||||
str(user.id): _email_local_part(getattr(user, "email", None))
|
||||
for user in users
|
||||
}
|
||||
expires_at = now + _OWNER_USERNAME_CACHE_SECONDS
|
||||
for user_id in missing_ids:
|
||||
local = loaded.get(user_id)
|
||||
_owner_username_cache[user_id] = (expires_at, local)
|
||||
if local:
|
||||
names[user_id] = local
|
||||
if len(_owner_username_cache) > _MAX_OWNER_USERNAME_CACHE_ENTRIES:
|
||||
expired = [key for key, value in _owner_username_cache.items() if value[0] <= now]
|
||||
for key in expired:
|
||||
_owner_username_cache.pop(key, None)
|
||||
if len(_owner_username_cache) > _MAX_OWNER_USERNAME_CACHE_ENTRIES:
|
||||
oldest = sorted(_owner_username_cache, key=lambda key: _owner_username_cache[key][0])
|
||||
excess = len(_owner_username_cache) - _MAX_OWNER_USERNAME_CACHE_ENTRIES
|
||||
for key in oldest[:excess]:
|
||||
_owner_username_cache.pop(key, None)
|
||||
user = None
|
||||
local = _email_local_part(getattr(user, "email", None)) if user is not None else None
|
||||
if local:
|
||||
names[uid] = local
|
||||
for resp in responses:
|
||||
if resp.owner_user_id:
|
||||
resp.owner_username = names.get(resp.owner_user_id)
|
||||
return responses
|
||||
|
||||
|
||||
async def _refresh_catalog_snapshot(config: AppConfig) -> None:
|
||||
"""Keep normalized MySQL skill rows current after a skill edit."""
|
||||
try:
|
||||
await refresh_skill_catalog_projection(config)
|
||||
except Exception:
|
||||
# A failed projection refresh must not turn a successful skill write
|
||||
# into an API failure. Startup or the next edit can recover it.
|
||||
logger.exception("Skill catalog projection refresh failed after a mutation")
|
||||
|
||||
|
||||
def _can_view_skill_source(
|
||||
category: SkillCategory,
|
||||
owner_user_id: str | None,
|
||||
@@ -373,7 +316,6 @@ def _skill_to_response(
|
||||
skill: Skill,
|
||||
ownership: dict[str, Any] | None = None,
|
||||
*,
|
||||
usage_entry: dict[str, Any] | None = None,
|
||||
display_override: dict[str, Any] | None | object = _UNSET,
|
||||
display_sample: dict[str, Any] | None = None,
|
||||
favorited: bool = False,
|
||||
@@ -385,12 +327,11 @@ def _skill_to_response(
|
||||
``owner_user_id`` / ``published`` / ``builtin`` fields used for per-user
|
||||
visibility and the frontend's owner badges.
|
||||
"""
|
||||
from deerflow.skills.usage import get_entry
|
||||
from deerflow.skills.usage import get_entry, latest_activity_at
|
||||
|
||||
entry = usage_entry if usage_entry is not None else get_entry(skill.name)
|
||||
entry = get_entry(skill.name)
|
||||
created_at_str = entry.get("created_at")
|
||||
activity_candidates = [entry.get("last_used_at"), entry.get("last_viewed_at"), entry.get("last_patched_at")]
|
||||
last_at_str = max((value for value in activity_candidates if value), default=created_at_str)
|
||||
last_at_str = latest_activity_at(skill.name)
|
||||
created_at: datetime | None = None
|
||||
last_at: datetime | None = None
|
||||
if created_at_str:
|
||||
@@ -464,93 +405,14 @@ def _skill_to_response(
|
||||
)
|
||||
|
||||
|
||||
def _catalog_item_to_response(
|
||||
item: dict[str, Any],
|
||||
ownership: dict[str, Any] | None,
|
||||
*,
|
||||
adapter: dict[str, Any] | None,
|
||||
favorited: bool,
|
||||
) -> SkillResponse:
|
||||
"""Build a list response from the MySQL snapshot and MySQL metadata rows."""
|
||||
|
||||
try:
|
||||
category = SkillCategory(str(item.get("category") or SkillCategory.PUBLIC.value))
|
||||
except ValueError:
|
||||
category = SkillCategory.PUBLIC
|
||||
owner_user_id = ownership.get("owner_user_id") if ownership else None
|
||||
return SkillResponse(
|
||||
name=str(item.get("name") or ""),
|
||||
name_zh=ownership.get("name_zh") if ownership else None,
|
||||
description=str(item.get("description") or ""),
|
||||
license=item.get("license"),
|
||||
category=category,
|
||||
enabled=bool(item.get("enabled", True)),
|
||||
always_on=bool(ownership.get("always_on", item.get("always_on", False)) if ownership else item.get("always_on", False)),
|
||||
use_count=int(item.get("use_count") or 0),
|
||||
view_count=int(item.get("view_count") or 0),
|
||||
patch_count=int(item.get("patch_count") or 0),
|
||||
last_activity_at=item.get("last_activity_at"),
|
||||
created_at=item.get("created_at"),
|
||||
state=str(item.get("state") or "active"),
|
||||
pinned=bool(item.get("pinned")),
|
||||
featured=bool(item.get("featured")),
|
||||
source=str(item.get("source") or "upload"),
|
||||
owner_user_id=owner_user_id,
|
||||
published=bool(ownership.get("published", False)) if ownership else False,
|
||||
square_id=str(ownership.get("square_id") or "") if ownership else "",
|
||||
builtin=bool(ownership.get("builtin", owner_user_id is None)) if ownership else category != SkillCategory.CUSTOM,
|
||||
favorited=favorited,
|
||||
detail=(ownership.get("detail_preview") or ownership.get("detail")) if ownership else None,
|
||||
display=adapter.get("display") if adapter else None,
|
||||
displaySample=adapter.get("sample") if adapter else None,
|
||||
)
|
||||
|
||||
|
||||
# ``checkfirst=True`` is a check-then-create operation. The in-process lock
|
||||
# serializes concurrent requests in one worker; the duplicate-table fallback
|
||||
# covers two Gateway workers racing during first access.
|
||||
_SKILL_DISPLAY_TABLE_LOCK = asyncio.Lock()
|
||||
_skill_display_table_engine: object | None = None
|
||||
|
||||
|
||||
def _skill_display_table_already_exists(exc: BaseException) -> bool:
|
||||
message = str(exc).lower()
|
||||
return any(
|
||||
token in message
|
||||
for token in (
|
||||
"already exists",
|
||||
"duplicate table",
|
||||
"42p07",
|
||||
"error 1050",
|
||||
"(1050",
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
async def _ensure_skill_display_table() -> bool:
|
||||
"""Create the display adapter table once when DB persistence is enabled."""
|
||||
global _skill_display_table_engine
|
||||
|
||||
"""Create the display adapter table when DB persistence is enabled."""
|
||||
engine = get_engine()
|
||||
sf = get_session_factory()
|
||||
if engine is None or sf is None:
|
||||
return False
|
||||
if _skill_display_table_engine is engine:
|
||||
return True
|
||||
|
||||
async with _SKILL_DISPLAY_TABLE_LOCK:
|
||||
if _skill_display_table_engine is engine:
|
||||
return True
|
||||
try:
|
||||
async with engine.begin() as conn:
|
||||
await conn.run_sync(SkillDisplayAdapterRow.__table__.create, checkfirst=True)
|
||||
except Exception as exc:
|
||||
# The transaction context rolled back before this exception is
|
||||
# accepted as the harmless result of another worker winning.
|
||||
if not _skill_display_table_already_exists(exc):
|
||||
raise
|
||||
logger.info("Skill display adapter table was created concurrently; continuing")
|
||||
_skill_display_table_engine = engine
|
||||
async with engine.begin() as conn:
|
||||
await conn.run_sync(SkillDisplayAdapterRow.__table__.create, checkfirst=True)
|
||||
return True
|
||||
|
||||
|
||||
@@ -599,18 +461,14 @@ async def _list_skill_display_adapters(skill_names: list[str]) -> dict[str, dict
|
||||
return {}
|
||||
async with sf() as session:
|
||||
result = await session.execute(
|
||||
select(SkillDisplayAdapterRow.skill_name, SkillDisplayAdapterRow.display_config).where(
|
||||
SkillDisplayAdapterRow.skill_name.in_(skill_names)
|
||||
)
|
||||
select(SkillDisplayAdapterRow).where(SkillDisplayAdapterRow.skill_name.in_(skill_names))
|
||||
)
|
||||
return {
|
||||
str(row.skill_name): {
|
||||
row.skill_name: {
|
||||
"display": _json_text_loads(row.display_config),
|
||||
# The editor reads LONGTEXT sample_payload on demand; the list
|
||||
# API only needs the lightweight display mapping.
|
||||
"sample": None,
|
||||
"sample": _json_text_loads(row.sample_payload),
|
||||
}
|
||||
for row in result
|
||||
for row in result.scalars()
|
||||
}
|
||||
|
||||
|
||||
@@ -821,7 +679,7 @@ async def _generate_skill_display_sample(skill: Skill, app_config: AppConfig) ->
|
||||
if parsed:
|
||||
return parsed
|
||||
logger.warning("Skill display sample model returned non-JSON for %s; falling back to static mock", skill.name)
|
||||
except TimeoutError:
|
||||
except asyncio.TimeoutError:
|
||||
logger.warning("Skill display sample LLM call timed out for %s; falling back to static mock", skill.name)
|
||||
except Exception:
|
||||
logger.warning("Skill display sample LLM call failed for %s; falling back to static mock", skill.name, exc_info=True)
|
||||
@@ -919,51 +777,20 @@ async def _build_ownership_index(skill_store: SkillStore, user_id: str) -> dict[
|
||||
return {record["name"]: record for record in records}
|
||||
|
||||
|
||||
def _skill_search_tokens(search: str | None) -> list[str]:
|
||||
"""Split a search query into lowercase AND-tokens (whitespace separated).
|
||||
|
||||
``网页 报告`` therefore requires both words to appear, but each may live in
|
||||
a different field (name vs description) — unlike the old contiguous
|
||||
substring match which demanded the whole phrase verbatim.
|
||||
"""
|
||||
if not search:
|
||||
return []
|
||||
return [token for token in search.strip().lower().split() if token]
|
||||
|
||||
|
||||
def _skill_matches_tokens(skill: SkillResponse, tokens: list[str]) -> bool:
|
||||
"""Every token must appear in at least one searchable skill field.
|
||||
|
||||
Fields: English name, Chinese display name, the SKILL.md ``description``,
|
||||
the long-form ``detail`` annotation, and assigned tag names — so users can
|
||||
find a skill by what it does, not only by its name.
|
||||
"""
|
||||
if not tokens:
|
||||
return True
|
||||
haystacks = [
|
||||
(skill.name or "").lower(),
|
||||
(skill.name_zh or "").lower(),
|
||||
(skill.description or "").lower(),
|
||||
(skill.detail or "").lower(),
|
||||
" ".join(str(t.get("name") or "").lower() for t in (skill.tags or [])),
|
||||
]
|
||||
return all(any(token in field for field in haystacks) for token in tokens)
|
||||
|
||||
|
||||
async def _attach_and_filter_tags(
|
||||
tag_store: TagStore,
|
||||
responses: list[SkillResponse],
|
||||
search: str | None,
|
||||
tag_ids: list[str] | None,
|
||||
) -> list[SkillResponse]:
|
||||
"""Bulk-attach tags to skill responses, then apply search/tag filters."""
|
||||
"""Bulk-attach tags to skill responses, then apply name/tag filters."""
|
||||
assignments = await tag_store.list_assignments("skill", [r.name for r in responses])
|
||||
for resp in responses:
|
||||
resp.tags = assignments.get(resp.name, [])
|
||||
if search:
|
||||
# Tags are attached first so tag names participate in the match.
|
||||
tokens = _skill_search_tokens(search)
|
||||
responses = [r for r in responses if _skill_matches_tokens(r, tokens)]
|
||||
needle = search.strip().lower()
|
||||
# Match the English name OR the Chinese display name so 中文 search works.
|
||||
responses = [r for r in responses if needle in r.name.lower() or (r.name_zh or "").lower().find(needle) >= 0]
|
||||
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)]
|
||||
@@ -992,7 +819,7 @@ async def list_skills(
|
||||
config: AppConfig = Depends(get_config),
|
||||
skill_store: SkillStore = Depends(get_skill_store),
|
||||
tag_store: TagStore = Depends(get_tag_store),
|
||||
search: str | None = Query(default=None, description="Whitespace-separated keywords (AND); case-insensitive substring match against skill name, Chinese name (name_zh), description, detail, and tag names"),
|
||||
search: str | None = Query(default=None, description="Case-insensitive fuzzy match on skill name or Chinese name (name_zh)"),
|
||||
tag_ids: list[str] | None = Query(default=None, description="Keep skills carrying any of these tags (OR)"),
|
||||
square: str | None = Query(default=None, description="Keep only skills filed under this publish square (发布广场). Omit for all squares."),
|
||||
scope: str | None = Query(default=None, description="``mine`` filters to the skills the caller's 岗位 (position) makes visible."),
|
||||
@@ -1010,138 +837,68 @@ async def list_skills(
|
||||
),
|
||||
),
|
||||
) -> SkillsListResponse:
|
||||
trace = trace_request(request, "skills_list")
|
||||
cache_fill_token: str | None = None
|
||||
cache_config = None
|
||||
cache_key = ""
|
||||
try:
|
||||
user_id = _current_user_id(request)
|
||||
if admin and not _is_admin_user(request):
|
||||
raise HTTPException(status_code=403, detail="Only system admins can list all skills")
|
||||
cacheable = (
|
||||
not admin
|
||||
and not (search or "").strip()
|
||||
and not tag_ids
|
||||
and not (square or "").strip()
|
||||
and sort == "time_desc"
|
||||
)
|
||||
query_fingerprint = json.dumps(
|
||||
{
|
||||
"search": search,
|
||||
"tag_ids": sorted(tag_ids or []),
|
||||
"square": square,
|
||||
"scope": scope,
|
||||
"sort": sort,
|
||||
},
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
)
|
||||
cache_key = f"user:{user_id}:query:{query_fingerprint}" if cacheable else ""
|
||||
cache_version = None
|
||||
request_app_state = getattr(getattr(request, "app", None), "state", None)
|
||||
cache_config = getattr(request_app_state, "config", config)
|
||||
if cacheable:
|
||||
stage_started = time.perf_counter()
|
||||
cache_version = await get_cache_version(cache_config, "skills")
|
||||
cached_payload = await get_cached_json_payload(
|
||||
cache_config,
|
||||
"skills",
|
||||
cache_key,
|
||||
version=cache_version,
|
||||
)
|
||||
if cached_payload is None:
|
||||
cached_payload, cache_fill_token = await wait_for_cached_json_payload_or_claim_fill(
|
||||
cache_config,
|
||||
"skills",
|
||||
cache_key,
|
||||
version=cache_version,
|
||||
)
|
||||
trace_stage(trace, "skills_redis_cache", stage_started)
|
||||
if cached_payload is not None:
|
||||
trace.setdefault("details", {})["cache"] = "redis_hit"
|
||||
return Response(content=cached_payload, media_type="application/json")
|
||||
stage_started = time.perf_counter()
|
||||
catalog = await load_skill_catalog_projection(user_id=user_id, admin=admin)
|
||||
if catalog is None:
|
||||
# Preserve no-database operation. A MySQL-backed request always
|
||||
# uses the normalized rows and does not scan SKILL.md files.
|
||||
legacy_catalog = await load_or_warm_skill_catalog_snapshot(config)
|
||||
if legacy_catalog is not None:
|
||||
catalog = legacy_catalog
|
||||
trace_stage(trace, "skills_legacy_projection_fallback", stage_started)
|
||||
else:
|
||||
# This request's dependency and the singleton share the active
|
||||
# app config. Reuse the process instance to retain parsed skill
|
||||
# metadata between catalogue reads.
|
||||
storage = get_or_new_skill_storage(app_config=config)
|
||||
skills_from_disk = await asyncio.to_thread(storage.load_skills, enabled_only=False)
|
||||
usage_entries = await asyncio.to_thread(_load_usage_entries)
|
||||
catalog = await asyncio.to_thread(_build_catalog_payload, skills_from_disk, usage_entries)
|
||||
trace_stage(trace, "skills_memory_mode_catalog_load", stage_started)
|
||||
else:
|
||||
trace_stage(trace, "skills_mysql_projection", stage_started)
|
||||
trace.setdefault("details", {})["skills_discovered"] = len(catalog)
|
||||
if get_session_factory() is not None:
|
||||
# Projection rows include the compact ownership fields; never load
|
||||
# the SkillRow.detail LONGTEXT column on catalog requests.
|
||||
ownership = {str(record["name"]): record for record in catalog}
|
||||
trace_stage(trace, "skills_ownership_in_projection", stage_started)
|
||||
elif admin:
|
||||
stage_started = time.perf_counter()
|
||||
all_skills = get_or_new_skill_storage(app_config=config).load_skills(enabled_only=False)
|
||||
if admin:
|
||||
ownership_records = await skill_store.list_all()
|
||||
ownership = {record["name"]: record for record in ownership_records}
|
||||
trace_stage(trace, "skills_ownership_db", stage_started)
|
||||
else:
|
||||
stage_started = time.perf_counter()
|
||||
ownership = await _build_ownership_index(skill_store, user_id)
|
||||
trace_stage(trace, "skills_ownership_db", stage_started)
|
||||
# Skills the caller's 岗位 (position) granted into their "我的技能"
|
||||
# collection. Admins browse everything, so the badge is moot for them.
|
||||
favorite_names: set[str] = set()
|
||||
if not admin:
|
||||
try:
|
||||
stage_started = time.perf_counter()
|
||||
favorite_names = await skill_store.list_favorite_skill_names(user_id)
|
||||
trace_stage(trace, "skills_favorites_db", stage_started)
|
||||
except Exception:
|
||||
logger.debug("skill favorites lookup failed", exc_info=True)
|
||||
favorite_names = set()
|
||||
stage_started = time.perf_counter()
|
||||
skill_names = [str(item["name"]) for item in catalog if item.get("name")]
|
||||
display_adapters = await _list_skill_display_adapters(skill_names)
|
||||
trace_stage(trace, "skills_display_adapters_db", stage_started)
|
||||
stage_started = time.perf_counter()
|
||||
display_adapters = await _list_skill_display_adapters([skill.name for skill in all_skills])
|
||||
responses: list[SkillResponse] = []
|
||||
for item in catalog:
|
||||
skill_name = str(item.get("name") or "")
|
||||
if not skill_name:
|
||||
continue
|
||||
try:
|
||||
category = SkillCategory(str(item.get("category") or SkillCategory.PUBLIC.value))
|
||||
except ValueError:
|
||||
category = SkillCategory.PUBLIC
|
||||
adapter = display_adapters.get(skill_name)
|
||||
record = ownership.get(skill_name)
|
||||
for skill in all_skills:
|
||||
adapter = display_adapters.get(skill.name)
|
||||
# Public/built-in skills (no DB row) are visible to everyone.
|
||||
# Custom skills must have an ownership record in the visible set.
|
||||
if category == SkillCategory.CUSTOM and record is None and not admin and skill_name not in favorite_names:
|
||||
if skill.category != SkillCategory.CUSTOM:
|
||||
# Built-in skills usually have no DB row, but an admin-authored
|
||||
# ``detail`` annotation materializes one — surface it when present.
|
||||
responses.append(
|
||||
_skill_to_response(
|
||||
skill,
|
||||
ownership.get(skill.name),
|
||||
display_override=_display_override_from_adapter(adapter),
|
||||
display_sample=adapter.get("sample") if adapter else None,
|
||||
favorited=skill.name in favorite_names,
|
||||
)
|
||||
)
|
||||
continue
|
||||
record = ownership.get(skill.name)
|
||||
if record is None:
|
||||
if admin:
|
||||
# Admin sees every custom skill on disk even without an
|
||||
# ownership row (legacy / orphaned), so they can clean it up.
|
||||
record = None
|
||||
elif skill.name in favorite_names:
|
||||
# A position granted this skill even though it isn't
|
||||
# otherwise visible to the user (e.g. an unpublished custom
|
||||
# skill). Surface it so it lands in their 我的技能.
|
||||
record = await skill_store.get_any(skill.name)
|
||||
else:
|
||||
continue
|
||||
responses.append(
|
||||
_catalog_item_to_response(
|
||||
item,
|
||||
_skill_to_response(
|
||||
skill,
|
||||
record,
|
||||
adapter=adapter,
|
||||
favorited=skill_name in favorite_names,
|
||||
display_override=_display_override_from_adapter(adapter),
|
||||
display_sample=adapter.get("sample") if adapter else None,
|
||||
favorited=skill.name in favorite_names,
|
||||
)
|
||||
)
|
||||
trace_stage(trace, "skills_response_assembly", stage_started)
|
||||
stage_started = time.perf_counter()
|
||||
responses = await _attach_and_filter_tags(tag_store, responses, search, tag_ids)
|
||||
trace_stage(trace, "skills_tags_db_and_filter", stage_started)
|
||||
stage_started = time.perf_counter()
|
||||
responses = await _attach_owner_usernames(responses)
|
||||
trace_stage(trace, "skills_owner_usernames_db", stage_started)
|
||||
square_id = square.strip() if square and square.strip() else None
|
||||
if square_id:
|
||||
from deerflow.config.system_settings import load_system_settings, resolve_default_square_id
|
||||
@@ -1158,30 +915,13 @@ async def list_skills(
|
||||
# mirroring how agents are added to 我的智能体. The browse-all 广场 therefore
|
||||
# always shows every visible skill — the ``scope`` param is kept for API
|
||||
# compatibility but intentionally does not filter here.
|
||||
stage_started = time.perf_counter()
|
||||
responses = _sort_skill_responses(responses, sort)
|
||||
trace_stage(trace, "skills_sort", stage_started)
|
||||
trace.setdefault("details", {})["skills_returned"] = len(responses)
|
||||
result = SkillsListResponse(skills=responses)
|
||||
if cacheable:
|
||||
await set_cached_json(
|
||||
cache_config,
|
||||
"skills",
|
||||
cache_key,
|
||||
result,
|
||||
expected_version=cache_version,
|
||||
)
|
||||
trace.setdefault("details", {})["cache"] = "redis_miss"
|
||||
return result
|
||||
return SkillsListResponse(skills=responses)
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to load skills: {e}", exc_info=True)
|
||||
raise HTTPException(status_code=500, detail=f"Failed to load skills: {str(e)}")
|
||||
finally:
|
||||
if cache_fill_token is not None and cache_config is not None and cache_key:
|
||||
await release_cache_fill(cache_config, "skills", cache_key, cache_fill_token)
|
||||
finish_trace(trace)
|
||||
|
||||
|
||||
_MAX_SKILL_UPLOAD_BYTES = 512 * 1024 * 1024
|
||||
@@ -1360,7 +1100,6 @@ async def install_skill_upload(
|
||||
await skill_store.ensure_legacy(
|
||||
{"name": result["skill_name"], "owner_user_id": user_id, "published": False}
|
||||
)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
await refresh_skills_system_prompt_cache_async()
|
||||
return SkillInstallResponse(**result)
|
||||
except FileNotFoundError as e:
|
||||
@@ -1616,7 +1355,6 @@ async def install_skill(
|
||||
await skill_store.ensure_legacy(
|
||||
{"name": result.skill_name, "owner_user_id": user_id, "published": False}
|
||||
)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
await refresh_skills_system_prompt_cache_async()
|
||||
return result
|
||||
except FileNotFoundError as e:
|
||||
@@ -1730,7 +1468,6 @@ async def duplicate_skill(
|
||||
mark_uploaded(new_name)
|
||||
except Exception:
|
||||
pass
|
||||
await _refresh_catalog_snapshot(config)
|
||||
await refresh_skills_system_prompt_cache_async()
|
||||
return SkillInstallResponse(
|
||||
success=True,
|
||||
@@ -1804,16 +1541,9 @@ async def list_custom_skills(
|
||||
) -> SkillsListResponse:
|
||||
try:
|
||||
user_id = _current_user_id(request)
|
||||
storage = get_or_new_skill_storage()
|
||||
all_skills, usage_entries = await asyncio.gather(
|
||||
asyncio.to_thread(storage.load_skills, enabled_only=False),
|
||||
asyncio.to_thread(_load_usage_entries),
|
||||
)
|
||||
custom = [skill for skill in all_skills if skill.category == SkillCategory.CUSTOM]
|
||||
ownership, display_adapters = await asyncio.gather(
|
||||
_build_ownership_index(skill_store, user_id),
|
||||
_list_skill_display_adapters([skill.name for skill in custom]),
|
||||
)
|
||||
custom = [s for s in get_or_new_skill_storage(app_config=config).load_skills(enabled_only=False) if s.category == SkillCategory.CUSTOM]
|
||||
ownership = await _build_ownership_index(skill_store, user_id)
|
||||
display_adapters = await _list_skill_display_adapters([skill.name for skill in custom])
|
||||
responses = []
|
||||
for skill in custom:
|
||||
if skill.name not in ownership:
|
||||
@@ -1823,7 +1553,6 @@ async def list_custom_skills(
|
||||
_skill_to_response(
|
||||
skill,
|
||||
ownership[skill.name],
|
||||
usage_entry=usage_entries.get(skill.name, {}),
|
||||
display_override=_display_override_from_adapter(adapter),
|
||||
display_sample=adapter.get("sample") if adapter else None,
|
||||
)
|
||||
@@ -1871,7 +1600,6 @@ async def update_custom_skill(skill_name: str, request: CustomSkillUpdateRequest
|
||||
raise HTTPException(status_code=400, detail=f"Security scan blocked the edit: {scan.reason}")
|
||||
prev_content = storage.read_custom_skill(skill_name)
|
||||
storage.write_custom_skill(skill_name, SKILL_MD_FILE, request.content)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
storage.append_history(
|
||||
skill_name,
|
||||
{
|
||||
@@ -1941,7 +1669,6 @@ async def delete_custom_skill(
|
||||
await skill_store.delete_admin(skill_name)
|
||||
else:
|
||||
await skill_store.delete(skill_name, user_id)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
|
||||
try:
|
||||
await get_tag_store(request).unassign_all("skill", skill_name)
|
||||
@@ -2044,7 +1771,6 @@ async def delete_builtin_skill(
|
||||
skill_owner_user_id=None,
|
||||
agent_store=agent_store,
|
||||
)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
await refresh_skills_system_prompt_cache_async()
|
||||
await _sync_skill_view(skill.name)
|
||||
logger.info("Administrator deleted built-in skill %s", skill.name)
|
||||
@@ -2187,7 +1913,6 @@ async def update_custom_skill_state(
|
||||
from deerflow.skills.usage import set_state as _usage_set_state
|
||||
|
||||
_usage_set_state(skill_name, body.state)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
await refresh_skills_system_prompt_cache_async()
|
||||
return _reload_skill_response(skill_name, record, config)
|
||||
except HTTPException:
|
||||
@@ -2219,7 +1944,6 @@ async def update_custom_skill_pinned(
|
||||
from deerflow.skills.usage import set_pinned as _usage_set_pinned
|
||||
|
||||
_usage_set_pinned(skill_name, body.pinned)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
return _reload_skill_response(skill_name, record, config)
|
||||
except HTTPException:
|
||||
raise
|
||||
@@ -2310,7 +2034,6 @@ async def rollback_custom_skill(skill_name: str, request: SkillRollbackRequest,
|
||||
storage.append_history(skill_name, history_entry)
|
||||
raise HTTPException(status_code=400, detail=f"Rollback blocked by security scanner: {scan.reason}")
|
||||
storage.write_custom_skill(skill_name, SKILL_MD_FILE, target_content)
|
||||
await _refresh_catalog_snapshot(config)
|
||||
storage.append_history(skill_name, history_entry)
|
||||
await refresh_skills_system_prompt_cache_async()
|
||||
return await get_custom_skill(skill_name, config)
|
||||
@@ -3367,7 +3090,7 @@ async def _generate_skill_name_zh(skill: Skill, app_config: AppConfig, model: An
|
||||
),
|
||||
timeout=60,
|
||||
)
|
||||
except TimeoutError as e:
|
||||
except asyncio.TimeoutError as e:
|
||||
logger.warning("Skill name_zh LLM call timed out for %s", skill.name)
|
||||
raise SkillNameZhModelError("大模型响应超时(60 秒)") from e
|
||||
except Exception as e:
|
||||
|
||||
Reference in new issue
Block a user