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

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

No files matched your search

@@ -8,18 +8,34 @@ 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, Body, Depends, File, HTTPException, Query, Request, UploadFile
from fastapi import APIRouter, Depends, File, HTTPException, Query, Request, Response, 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
@@ -39,6 +55,9 @@ 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]] = {}
# ---------------------------------------------------------------------------
@@ -81,21 +100,59 @@ 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] = {}
for uid in owner_ids:
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:
try:
user = await provider.get_user(uid)
users = await provider.get_users_by_ids(sorted(missing_ids))
except Exception:
user = None
local = _email_local_part(getattr(user, "email", None)) if user is not None else None
if local:
names[uid] = local
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)
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,
@@ -316,6 +373,7 @@ 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,
@@ -327,11 +385,12 @@ 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, latest_activity_at
from deerflow.skills.usage import get_entry
entry = get_entry(skill.name)
entry = usage_entry if usage_entry is not None else get_entry(skill.name)
created_at_str = entry.get("created_at")
last_at_str = latest_activity_at(skill.name)
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)
created_at: datetime | None = None
last_at: datetime | None = None
if created_at_str:
@@ -405,14 +464,93 @@ 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 when DB persistence is enabled."""
"""Create the display adapter table once when DB persistence is enabled."""
global _skill_display_table_engine
engine = get_engine()
sf = get_session_factory()
if engine is None or sf is None:
return False
async with engine.begin() as conn:
await conn.run_sync(SkillDisplayAdapterRow.__table__.create, checkfirst=True)
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
return True
@@ -461,14 +599,18 @@ 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).where(SkillDisplayAdapterRow.skill_name.in_(skill_names))
select(SkillDisplayAdapterRow.skill_name, SkillDisplayAdapterRow.display_config).where(
SkillDisplayAdapterRow.skill_name.in_(skill_names)
)
)
return {
row.skill_name: {
str(row.skill_name): {
"display": _json_text_loads(row.display_config),
"sample": _json_text_loads(row.sample_payload),
# The editor reads LONGTEXT sample_payload on demand; the list
# API only needs the lightweight display mapping.
"sample": None,
}
for row in result.scalars()
for row in result
}
@@ -679,7 +821,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 asyncio.TimeoutError:
except 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)
@@ -777,20 +919,51 @@ 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 name/tag filters."""
"""Bulk-attach tags to skill responses, then apply search/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:
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]
# 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)]
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)]
@@ -819,7 +992,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="Case-insensitive fuzzy match on skill name or Chinese name (name_zh)"),
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"),
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."),
@@ -837,68 +1010,138 @@ 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")
all_skills = get_or_new_skill_storage(app_config=config).load_skills(enabled_only=False)
if admin:
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()
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()
display_adapters = await _list_skill_display_adapters([skill.name for skill in all_skills])
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()
responses: list[SkillResponse] = []
for skill in all_skills:
adapter = display_adapters.get(skill.name)
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)
# Public/built-in skills (no DB row) are visible to everyone.
# Custom skills must have an ownership record in the visible set.
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,
)
)
if category == SkillCategory.CUSTOM and record is None and not admin and skill_name not 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(
_skill_to_response(
skill,
_catalog_item_to_response(
item,
record,
display_override=_display_override_from_adapter(adapter),
display_sample=adapter.get("sample") if adapter else None,
favorited=skill.name in favorite_names,
adapter=adapter,
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
@@ -915,13 +1158,30 @@ 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)
return SkillsListResponse(skills=responses)
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
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
@@ -1100,6 +1360,7 @@ 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:
@@ -1355,6 +1616,7 @@ 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:
@@ -1468,6 +1730,7 @@ 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,
@@ -1541,9 +1804,16 @@ async def list_custom_skills(
) -> SkillsListResponse:
try:
user_id = _current_user_id(request)
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])
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]),
)
responses = []
for skill in custom:
if skill.name not in ownership:
@@ -1553,6 +1823,7 @@ 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,
)
@@ -1600,6 +1871,7 @@ 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,
{
@@ -1669,6 +1941,7 @@ 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)
@@ -1771,6 +2044,7 @@ 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)
@@ -1913,6 +2187,7 @@ 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:
@@ -1944,6 +2219,7 @@ 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
@@ -2034,6 +2310,7 @@ 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)
@@ -3090,7 +3367,7 @@ async def _generate_skill_name_zh(skill: Skill, app_config: AppConfig, model: An
),
timeout=60,
)
except asyncio.TimeoutError as e:
except 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: