feat: 技能收藏与常驻(always-on)支持
- 新增 skill_favorites / skill_always_on 迁移与持久化模型字段 - skills 路由、存储、前端设置页支持收藏与常驻 - 调整摘要中间件与 lead agent 提示词 - 同步岗位 position_sync 及相关配置清理 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
1 parent
5ebbb82d66
commit
5182ea5d11
19 files changed
+472
-107
No files matched your search
+52
-2
@@ -86,8 +86,58 @@ def _drop_archived_skills(skills: list[Skill]) -> list[Skill]:
|
||||
return skills
|
||||
|
||||
|
||||
def _run_coro_blocking(coro):
|
||||
"""Run an async coroutine to completion from sync code.
|
||||
|
||||
Mirrors ``skill_tools._run_coro_blocking``: when already inside a running
|
||||
event loop (e.g. prompt built during an async agent run), hand the coroutine
|
||||
to a fresh loop in a worker thread; otherwise run it directly.
|
||||
"""
|
||||
try:
|
||||
asyncio.get_running_loop()
|
||||
in_loop = True
|
||||
except RuntimeError:
|
||||
in_loop = False
|
||||
|
||||
if in_loop:
|
||||
import concurrent.futures
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
|
||||
return pool.submit(asyncio.run, coro).result()
|
||||
return asyncio.run(coro)
|
||||
|
||||
|
||||
def _load_always_on_names() -> set[str]:
|
||||
"""Names marked 常驻(免压缩), read from the **DB** (skills table).
|
||||
|
||||
Returns an empty set on any failure / no-DB deployment, so compression then
|
||||
simply treats every skill as compressible (safe default).
|
||||
"""
|
||||
try:
|
||||
from deerflow.persistence.engine import get_session_factory
|
||||
from deerflow.persistence.skills import make_skill_store
|
||||
|
||||
store = make_skill_store(get_session_factory())
|
||||
return set(_run_coro_blocking(store.list_always_on_names()))
|
||||
except Exception:
|
||||
logger.debug("Failed to load always_on skill names from DB", exc_info=True)
|
||||
return set()
|
||||
|
||||
|
||||
def _apply_always_on(skills: list[Skill]) -> list[Skill]:
|
||||
"""Stamp ``Skill.always_on`` from the DB-backed 常驻 set (in place)."""
|
||||
try:
|
||||
always_on = _load_always_on_names()
|
||||
if always_on:
|
||||
for skill in skills:
|
||||
skill.always_on = skill.name in always_on
|
||||
except Exception:
|
||||
logger.debug("Failed to apply always_on flags to skills", exc_info=True)
|
||||
return skills
|
||||
|
||||
|
||||
def _load_enabled_skills_sync() -> list[Skill]:
|
||||
return _drop_archived_skills(list(get_or_new_skill_storage().load_skills(enabled_only=True)))
|
||||
return _apply_always_on(_drop_archived_skills(list(get_or_new_skill_storage().load_skills(enabled_only=True))))
|
||||
|
||||
|
||||
def _start_enabled_skills_refresh_thread() -> None:
|
||||
@@ -188,7 +238,7 @@ def _get_enabled_skills_for_config(app_config: AppConfig | None = None) -> list[
|
||||
"""
|
||||
if app_config is None:
|
||||
return _get_enabled_skills()
|
||||
return _drop_archived_skills(list(get_or_new_skill_storage(app_config=app_config).load_skills(enabled_only=True)))
|
||||
return _apply_always_on(_drop_archived_skills(list(get_or_new_skill_storage(app_config=app_config).load_skills(enabled_only=True))))
|
||||
|
||||
|
||||
def _skill_mutability_label(category: SkillCategory | str) -> str:
|
||||
|
||||
+41
-2
@@ -314,16 +314,36 @@ class DeerFlowSummarizationMiddleware(SummarizationMiddleware):
|
||||
logger.debug("summarization: thread_id unresolved; cross-turn summary cache disabled for this call")
|
||||
cached = self._get_cache_entry(thread_id) if thread_id else None
|
||||
present_ids = {m.id for m in messages}
|
||||
if cached is not None and cached.reusable and cached.summarized_ids <= present_ids:
|
||||
cache_usable = cached is not None and cached.reusable and cached.summarized_ids <= present_ids
|
||||
if cache_usable:
|
||||
preserved = [m for m in messages if m.id not in cached.summarized_ids]
|
||||
effective = [self._summary_message(cached.summary_text), *preserved]
|
||||
if not self._should_summarize(effective, self.token_counter(effective)):
|
||||
# Decide re-summarization on the *counted* size of the compressed
|
||||
# context only — NOT ``_should_summarize`` — because that folds in the
|
||||
# last AIMessage's reported ``usage_metadata`` (system prompt + tool
|
||||
# schemas, fixed overhead compression can't shrink). Using it here
|
||||
# would re-summarize on every single turn once that overhead alone
|
||||
# approaches the trigger.
|
||||
if not self._exceeds_trigger_by_count(effective):
|
||||
# Refresh LRU recency and reuse without an LLM call.
|
||||
self._touch_cache_entry(thread_id)
|
||||
return ("reuse", effective)
|
||||
# New messages have pushed the compressed context back over the
|
||||
# threshold — fall through and re-summarize a larger prefix.
|
||||
|
||||
# Genuine (blocking) LLM summarize path. Log *why* we are paying for it so
|
||||
# an "it compacts every turn" report is diagnosable straight from the
|
||||
# backend log: cache=miss → thread_id/key problem; unusable → message-id
|
||||
# instability; stale → preserved genuinely grew back over the trigger.
|
||||
cache_state = "stale" if cache_usable else ("miss" if cached is None else "unusable")
|
||||
logger.info(
|
||||
"summarization: compacting thread=%s cache=%s counted_tokens=%d msgs=%d",
|
||||
thread_id,
|
||||
cache_state,
|
||||
self.token_counter(messages),
|
||||
len(messages),
|
||||
)
|
||||
|
||||
cutoff_index = self._determine_cutoff_index(messages)
|
||||
if cutoff_index <= 0:
|
||||
return None
|
||||
@@ -386,6 +406,25 @@ class DeerFlowSummarizationMiddleware(SummarizationMiddleware):
|
||||
while len(self._summary_cache) > _SUMMARY_CACHE_MAX_THREADS:
|
||||
self._summary_cache.popitem(last=False)
|
||||
|
||||
def _exceeds_trigger_by_count(self, messages: list[AnyMessage]) -> bool:
|
||||
"""Trigger check using only the *counted* size of ``messages``.
|
||||
|
||||
Deliberately ignores the stock middleware's reported-``usage_metadata``
|
||||
heuristic: that number includes fixed system-prompt + tool-schema
|
||||
overhead which compression can never shrink, so relying on it to decide
|
||||
*re*-summarization makes a long, tool-heavy thread re-compact on every
|
||||
turn. The first-ever decision to compress still uses the full
|
||||
``_should_summarize`` (reported usage is a fair signal there); only the
|
||||
cache-reuse-vs-recompact decision uses this stricter, content-only check.
|
||||
"""
|
||||
total = self.token_counter(messages)
|
||||
for kind, value in getattr(self, "_trigger_conditions", []):
|
||||
if kind == "messages" and len(messages) >= value:
|
||||
return True
|
||||
if kind == "tokens" and total >= value:
|
||||
return True
|
||||
return False
|
||||
|
||||
def _apply_stickiness_headroom(self, messages: list[AnyMessage], cutoff_index: int) -> int:
|
||||
"""Advance ``cutoff_index`` (keep fewer recent messages) so the preserved
|
||||
suffix lands below every trigger threshold with headroom.
|
||||
|
||||
@@ -910,7 +910,6 @@ class DeerFlowClient:
|
||||
current_skill_config = extensions_config.skills.get(name)
|
||||
extensions_config.skills[name] = SkillStateConfig(
|
||||
enabled=enabled,
|
||||
always_on=current_skill_config.always_on if current_skill_config else False,
|
||||
display=current_skill_config.display if current_skill_config else None,
|
||||
)
|
||||
|
||||
|
||||
-19
@@ -161,10 +161,6 @@ class SkillStateConfig(BaseModel):
|
||||
"""Configuration for a single skill's state."""
|
||||
|
||||
enabled: bool = Field(default=True, description="Whether this skill is enabled")
|
||||
always_on: bool = Field(
|
||||
default=False,
|
||||
description="常驻(免压缩):开启技能压缩后,本技能仍以全文形式注入系统提示词,而非降级为索引+search_skills 检索",
|
||||
)
|
||||
display: SkillDisplayConfig | None = Field(default=None, description="Optional frontend display adapter")
|
||||
|
||||
|
||||
@@ -317,21 +313,6 @@ class ExtensionsConfig(BaseModel):
|
||||
return skill_category in ("public", "custom")
|
||||
return skill_config.enabled
|
||||
|
||||
def is_skill_always_on(self, skill_name: str) -> bool:
|
||||
"""Check if a skill is marked 常驻(免压缩).
|
||||
|
||||
Args:
|
||||
skill_name: Name of the skill
|
||||
|
||||
Returns:
|
||||
True if the skill should bypass skill compression, False otherwise
|
||||
(default for skills without an explicit config entry).
|
||||
"""
|
||||
skill_config = self.skills.get(skill_name)
|
||||
if skill_config is None:
|
||||
return False
|
||||
return skill_config.always_on
|
||||
|
||||
|
||||
_extensions_config: ExtensionsConfig | None = None
|
||||
|
||||
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
"""我的技能 (skill favorites) table.
|
||||
|
||||
New table ``skill_favorites`` — the per-user "我的技能" collection, mirroring
|
||||
``agent_favorites``. A 岗位 (position) materializes its skill tag bindings into
|
||||
this table (``origin='position'``) so granted skills land in the member's 我的
|
||||
list while the browse-all 广场 stays complete.
|
||||
|
||||
Note: the running app also auto-creates this table via ``create_all`` on
|
||||
startup (new tables are always created, even on existing DBs); this migration
|
||||
keeps the alembic history consistent per the repo convention (see
|
||||
backend/CLAUDE.md → Schema Migrations).
|
||||
|
||||
Revision ID: 20260616_02
|
||||
Revises: 20260616_01
|
||||
Create Date: 2026-06-16
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
from sqlalchemy import inspect
|
||||
|
||||
|
||||
revision = "20260616_02"
|
||||
down_revision = "20260616_01"
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def _has_table(table_name: str) -> bool:
|
||||
return table_name in inspect(op.get_bind()).get_table_names()
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
if not _has_table("skill_favorites"):
|
||||
op.create_table(
|
||||
"skill_favorites",
|
||||
sa.Column("id", sa.String(64), primary_key=True),
|
||||
sa.Column("user_id", sa.String(64), nullable=False),
|
||||
sa.Column("skill_name", sa.String(64), nullable=False),
|
||||
sa.Column("origin", sa.String(16), nullable=False, server_default="user"),
|
||||
sa.Column("position_id", sa.String(64), nullable=True),
|
||||
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
|
||||
sa.UniqueConstraint("user_id", "skill_name", name="uq_skill_favorites_user_skill"),
|
||||
)
|
||||
op.create_index("ix_skill_favorites_user_id", "skill_favorites", ["user_id"])
|
||||
op.create_index("ix_skill_favorites_skill_name", "skill_favorites", ["skill_name"])
|
||||
op.create_index("ix_skill_favorites_position_id", "skill_favorites", ["position_id"])
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
if _has_table("skill_favorites"):
|
||||
op.drop_table("skill_favorites")
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
"""Add always_on (常驻/免压缩) column to skills table.
|
||||
|
||||
Revision ID: 20260616_03
|
||||
Revises: 20260616_02
|
||||
Create Date: 2026-06-16
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
from sqlalchemy import inspect
|
||||
|
||||
|
||||
revision = "20260616_03"
|
||||
down_revision = "20260616_02"
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def _has_table(table_name: str) -> bool:
|
||||
inspector = inspect(op.get_bind())
|
||||
return table_name in inspector.get_table_names()
|
||||
|
||||
|
||||
def _has_column(table_name: str, column_name: str) -> bool:
|
||||
if not _has_table(table_name):
|
||||
return False
|
||||
inspector = inspect(op.get_bind())
|
||||
return any(col["name"] == column_name for col in inspector.get_columns(table_name))
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
# ``skills`` may not exist yet on a brand-new DB — create_all handles that
|
||||
# case with the column already present, so only patch existing tables.
|
||||
if _has_table("skills") and not _has_column("skills", "always_on"):
|
||||
op.add_column(
|
||||
"skills",
|
||||
sa.Column("always_on", sa.Boolean(), nullable=False, server_default="0"),
|
||||
)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
if _has_column("skills", "always_on"):
|
||||
op.drop_column("skills", "always_on")
|
||||
+2
-1
@@ -60,7 +60,7 @@ from deerflow.persistence.scheduled_tasks.model import (
|
||||
ScheduledTaskSubscriptionRow,
|
||||
SchedulerThreadRow,
|
||||
)
|
||||
from deerflow.persistence.skills.model import SkillDisplayAdapterRow, SkillRow
|
||||
from deerflow.persistence.skills.model import SkillDisplayAdapterRow, SkillFavoriteRow, SkillRow
|
||||
from deerflow.persistence.tags.model import TagAssignmentRow, TagRow
|
||||
from deerflow.persistence.thread_meta.model import ThreadMetaRow
|
||||
from deerflow.persistence.embed_sessions.model import EmbedSessionRow
|
||||
@@ -110,6 +110,7 @@ __all__ = [
|
||||
"SchedulerThreadRow",
|
||||
"SkillRow",
|
||||
"SkillDisplayAdapterRow",
|
||||
"SkillFavoriteRow",
|
||||
"TagAssignmentRow",
|
||||
"TagRow",
|
||||
"EmbedSessionRow",
|
||||
|
||||
@@ -85,3 +85,23 @@ class SkillStore(ABC):
|
||||
DB round-trip per candidate skill.
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
@abstractmethod
|
||||
async def list_always_on_names(self) -> set[str]:
|
||||
"""Return the set of skill names marked 常驻(免压缩) (``always_on = True``).
|
||||
|
||||
Batch query used by the prompt builder to decide which skills bypass
|
||||
skill compression — one query instead of a per-skill round-trip.
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
@abstractmethod
|
||||
async def list_favorite_skill_names(self, user_id: str) -> set[str]:
|
||||
"""Return the skill names in ``user_id``'s "我的技能" collection.
|
||||
|
||||
These are skills the user does not own but that landed in their list —
|
||||
currently only via their 岗位 (position) sync (``origin='position'``).
|
||||
Owned skills are NOT included here (the caller detects those via
|
||||
``owner_user_id``).
|
||||
"""
|
||||
raise NotImplementedError
|
||||
+18
@@ -20,12 +20,15 @@ def _copy(record: dict[str, Any] | None) -> dict[str, Any] | None:
|
||||
def _with_derived(record: dict[str, Any]) -> dict[str, Any]:
|
||||
out = dict(record)
|
||||
out["builtin"] = out.get("owner_user_id") is None
|
||||
out.setdefault("always_on", False)
|
||||
return out
|
||||
|
||||
|
||||
class MemorySkillStore(SkillStore):
|
||||
def __init__(self) -> None:
|
||||
self._skills: dict[str, dict[str, Any]] = {}
|
||||
# user_id -> {skill_name}
|
||||
self._favorites: dict[str, set[str]] = {}
|
||||
|
||||
@staticmethod
|
||||
def _is_visible(record: dict[str, Any], user_id: str) -> bool:
|
||||
@@ -71,6 +74,7 @@ class MemorySkillStore(SkillStore):
|
||||
"published": bool(data.get("published", False)),
|
||||
"detail": data.get("detail"),
|
||||
"name_zh": data.get("name_zh"),
|
||||
"always_on": bool(data.get("always_on", False)),
|
||||
"square_id": str(data.get("square_id") or ""),
|
||||
"created_at": _now(),
|
||||
"updated_at": _now(),
|
||||
@@ -107,6 +111,8 @@ class MemorySkillStore(SkillStore):
|
||||
record["detail"] = data["detail"]
|
||||
if "name_zh" in data:
|
||||
record["name_zh"] = data["name_zh"]
|
||||
if "always_on" in data:
|
||||
record["always_on"] = bool(data["always_on"])
|
||||
if "square_id" in data:
|
||||
record["square_id"] = str(data["square_id"] or "")
|
||||
record["updated_at"] = _now()
|
||||
@@ -124,6 +130,8 @@ class MemorySkillStore(SkillStore):
|
||||
record["detail"] = data["detail"]
|
||||
if "name_zh" in data:
|
||||
record["name_zh"] = data["name_zh"]
|
||||
if "always_on" in data:
|
||||
record["always_on"] = bool(data["always_on"])
|
||||
if "square_id" in data:
|
||||
record["square_id"] = str(data["square_id"] or "")
|
||||
record["updated_at"] = _now()
|
||||
@@ -153,3 +161,13 @@ class MemorySkillStore(SkillStore):
|
||||
|
||||
async def list_published_names(self) -> set[str]:
|
||||
return {name for name, record in self._skills.items() if record.get("published")}
|
||||
|
||||
async def list_always_on_names(self) -> set[str]:
|
||||
return {name for name, record in self._skills.items() if record.get("always_on")}
|
||||
|
||||
async def list_favorite_skill_names(self, user_id: str) -> set[str]:
|
||||
return set(self._favorites.get(user_id, set()))
|
||||
|
||||
# test helper — not part of the abstract API
|
||||
def add_favorite(self, user_id: str, skill_name: str) -> None:
|
||||
self._favorites.setdefault(user_id, set()).add(skill_name)
|
||||
+32
-1
@@ -10,10 +10,11 @@ from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime
|
||||
|
||||
from sqlalchemy import Boolean, DateTime, String, Text
|
||||
from sqlalchemy import Boolean, DateTime, String, Text, UniqueConstraint
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from deerflow.persistence.base import Base
|
||||
from deerflow.persistence.types import BeijingDateTime
|
||||
|
||||
|
||||
class SkillRow(Base):
|
||||
@@ -33,6 +34,10 @@ class SkillRow(Base):
|
||||
# the on-disk SKILL.md) so it can be set for built-in skills too, and so the
|
||||
# shared source file is never rewritten.
|
||||
name_zh: Mapped[str | None] = mapped_column(String(128), nullable=True, default=None)
|
||||
# 常驻(免压缩):开启技能压缩后,标记此项的技能仍以全文形式注入系统提示词,而非
|
||||
# 降级为索引 + search_skills 检索。存 DB(而非 extensions_config.json),内置技能
|
||||
# 也能标记,且避免在某些部署里回写源码目录下的配置文件导致报错。
|
||||
always_on: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False, server_default="0", index=True)
|
||||
# Publish square (发布广场) this skill is filed under once published. Pure
|
||||
# organizational category, no access control. Empty string = unassigned →
|
||||
# the listing layer resolves it to the default square. One square per skill.
|
||||
@@ -41,6 +46,32 @@ class SkillRow(Base):
|
||||
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(UTC), onupdate=lambda: datetime.now(UTC))
|
||||
|
||||
|
||||
class SkillFavoriteRow(Base):
|
||||
"""A user's "我的技能" membership for a skill they don't own.
|
||||
|
||||
Mirrors :class:`deerflow.persistence.agents.model.AgentFavoriteRow`: lets a
|
||||
skill land in a user's "我的" list without the user owning it. Skills are
|
||||
keyed by ``name`` (the on-disk folder / DB primary key), so this row
|
||||
references ``skill_name`` rather than an opaque id. One row per
|
||||
(user, skill); the unique constraint makes the grant idempotent.
|
||||
"""
|
||||
|
||||
__tablename__ = "skill_favorites"
|
||||
__table_args__ = (UniqueConstraint("user_id", "skill_name", name="uq_skill_favorites_user_skill"),)
|
||||
|
||||
id: Mapped[str] = mapped_column(String(64), primary_key=True)
|
||||
user_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
|
||||
skill_name: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
|
||||
# ``"user"`` = the user added it themselves (reserved for a future favorite
|
||||
# button); ``"position"`` = auto-granted by the user's 岗位 (position) via
|
||||
# the subscription sync engine. Sync only ever adds/removes ``"position"``
|
||||
# rows, so a user's own picks are never clobbered.
|
||||
origin: Mapped[str] = mapped_column(String(16), nullable=False, default="user", server_default="user")
|
||||
# The position that granted this favorite (only set when ``origin='position'``).
|
||||
position_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
|
||||
created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC))
|
||||
|
||||
|
||||
class SkillDisplayAdapterRow(Base):
|
||||
__tablename__ = "skill_display_adapters"
|
||||
|
||||
|
||||
+18
-1
@@ -9,7 +9,7 @@ from sqlalchemy import func, or_, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
|
||||
|
||||
from deerflow.persistence.skills.base import SkillStore
|
||||
from deerflow.persistence.skills.model import SkillRow
|
||||
from deerflow.persistence.skills.model import SkillFavoriteRow, SkillRow
|
||||
|
||||
|
||||
def _row_to_dict(row: SkillRow) -> dict[str, Any]:
|
||||
@@ -65,6 +65,7 @@ class SkillRepository(SkillStore):
|
||||
published=bool(data.get("published", False)),
|
||||
detail=data.get("detail"),
|
||||
name_zh=data.get("name_zh"),
|
||||
always_on=bool(data.get("always_on", False)),
|
||||
square_id=str(data.get("square_id") or ""),
|
||||
created_at=now,
|
||||
updated_at=now,
|
||||
@@ -110,6 +111,8 @@ class SkillRepository(SkillStore):
|
||||
row.detail = data["detail"]
|
||||
if "name_zh" in data:
|
||||
row.name_zh = data["name_zh"]
|
||||
if "always_on" in data:
|
||||
row.always_on = bool(data["always_on"])
|
||||
if "square_id" in data:
|
||||
row.square_id = str(data["square_id"] or "")
|
||||
row.updated_at = datetime.now(UTC)
|
||||
@@ -130,6 +133,8 @@ class SkillRepository(SkillStore):
|
||||
row.detail = data["detail"]
|
||||
if "name_zh" in data:
|
||||
row.name_zh = data["name_zh"]
|
||||
if "always_on" in data:
|
||||
row.always_on = bool(data["always_on"])
|
||||
if "square_id" in data:
|
||||
row.square_id = str(data["square_id"] or "")
|
||||
row.updated_at = datetime.now(UTC)
|
||||
@@ -171,3 +176,15 @@ class SkillRepository(SkillStore):
|
||||
async with self._sf() as session:
|
||||
result = await session.execute(stmt)
|
||||
return {row[0] for row in result.all()}
|
||||
|
||||
async def list_always_on_names(self) -> set[str]:
|
||||
stmt = select(SkillRow.name).where(SkillRow.always_on.is_(True))
|
||||
async with self._sf() as session:
|
||||
result = await session.execute(stmt)
|
||||
return {row[0] for row in result.all()}
|
||||
|
||||
async def list_favorite_skill_names(self, user_id: str) -> set[str]:
|
||||
stmt = select(SkillFavoriteRow.skill_name).where(SkillFavoriteRow.user_id == user_id)
|
||||
async with self._sf() as session:
|
||||
result = await session.execute(stmt)
|
||||
return {row[0] for row in result.all()}
|
||||
+34
-15
@@ -1,9 +1,9 @@
|
||||
"""岗位 (position) → resource subscription **sync engine**.
|
||||
|
||||
A user's position decides which agents / scheduled tasks / custom prompts they
|
||||
are subscribed to, and which skills / recommended questions they can see. This
|
||||
service turns a position's *tag bindings* into concrete, materialized rows in
|
||||
the existing "我的" tables (idempotent, re-runnable).
|
||||
A user's position decides which agents / skills / scheduled tasks they are
|
||||
subscribed to, and which recommended questions they can see. This service turns
|
||||
a position's *tag bindings* into concrete, materialized rows in the existing
|
||||
"我的" tables (idempotent, re-runnable).
|
||||
|
||||
Resolution rule (per resource type):
|
||||
|
||||
@@ -14,15 +14,19 @@ Resolution rule (per resource type):
|
||||
* For a resource type **without** bound tags → the *default set*:
|
||||
- ``agent`` → all built-in agents (``user_id IS NULL``)
|
||||
- ``scheduled_task`` → empty (no built-in tasks)
|
||||
- ``skill`` / ``recommended_question`` → *unrestricted* (handled at query
|
||||
time, never materialized — see :meth:`resolve_visible`)
|
||||
- ``skill`` → empty (the 广场 still shows every visible skill;
|
||||
a position only *adds* its tagged skills to the member's "我的技能")
|
||||
- ``recommended_question`` → *unrestricted* (handled at query time, never
|
||||
materialized — see :meth:`resolve_visible`)
|
||||
|
||||
Materialization (``sync_user``) only ever touches rows it created itself
|
||||
(``origin='position'``), so a user's own favorites / subscriptions are never
|
||||
clobbered. The skill + recommended-question visibility filters are computed live
|
||||
by :meth:`resolve_visible` and are *not* materialized. (The admin-configured
|
||||
prompts shown to users ARE the recommended questions — there is no separate
|
||||
prompt-template store.)
|
||||
clobbered. ``skill`` is materialized into ``skill_favorites`` exactly like
|
||||
``agent`` → ``agent_favorites``: the tagged skills are *added* to the user's
|
||||
"我的技能" while the browse-all 广场 stays complete (it is **not** restricted).
|
||||
Only recommended-question visibility is computed live by :meth:`resolve_visible`
|
||||
and is *not* materialized. (The admin-configured prompts shown to users ARE the
|
||||
recommended questions — there is no separate prompt-template store.)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -37,14 +41,15 @@ from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
|
||||
from deerflow.persistence.agents.model import AgentFavoriteRow, AgentRow
|
||||
from deerflow.persistence.positions.base import PositionStore
|
||||
from deerflow.persistence.scheduled_tasks.model import ScheduledTaskSubscriptionRow
|
||||
from deerflow.persistence.skills.model import SkillFavoriteRow
|
||||
from deerflow.persistence.tags.base import TagStore
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Materialized into "我的" tables by sync_user.
|
||||
_MATERIALIZED_TYPES = ("agent", "scheduled_task")
|
||||
_MATERIALIZED_TYPES = ("agent", "skill", "scheduled_task")
|
||||
# Resolved live at query time (visibility filters), never materialized.
|
||||
_VISIBILITY_TYPES = ("skill", "recommended_question")
|
||||
_VISIBILITY_TYPES = ("recommended_question",)
|
||||
|
||||
|
||||
class PositionSyncService:
|
||||
@@ -64,9 +69,10 @@ class PositionSyncService:
|
||||
async def resolve_visible(self, user_id: str, resource_type: str) -> set[str] | None:
|
||||
"""Return the set of visible ``resource_type`` ids, or ``None`` = unrestricted.
|
||||
|
||||
Used by the skills list + recommended-questions filters. ``None`` means
|
||||
"no position restriction → show everything"; a set means "restrict to
|
||||
exactly these ids".
|
||||
Used by the recommended-questions filter (the only remaining query-time
|
||||
visibility type; skills are now *materialized*, not filtered). ``None``
|
||||
means "no position restriction → show everything"; a set means "restrict
|
||||
to exactly these ids".
|
||||
"""
|
||||
pid = await self._effective_position_id(user_id)
|
||||
if not pid:
|
||||
@@ -101,6 +107,7 @@ class PositionSyncService:
|
||||
pid = await self._effective_position_id(user_id)
|
||||
async with self._sf() as session:
|
||||
await self._sync_agents(session, user_id, pid)
|
||||
await self._sync_skills(session, user_id, pid)
|
||||
await self._sync_tasks(session, user_id, pid)
|
||||
await session.commit()
|
||||
|
||||
@@ -116,6 +123,18 @@ class PositionSyncService:
|
||||
if agent_id not in target:
|
||||
await session.delete(row)
|
||||
|
||||
async def _sync_skills(self, session: AsyncSession, user_id: str, position_id: str | None) -> None:
|
||||
target = await self._resolve_materialized(user_id, "skill", session)
|
||||
rows = list((await session.execute(select(SkillFavoriteRow).where(SkillFavoriteRow.user_id == user_id))).scalars())
|
||||
owned_any = {r.skill_name for r in rows}
|
||||
position_rows = {r.skill_name: r for r in rows if r.origin == "position"}
|
||||
now = datetime.now(UTC)
|
||||
for skill_name in target - owned_any:
|
||||
session.add(SkillFavoriteRow(id=uuid.uuid4().hex, user_id=user_id, skill_name=skill_name, origin="position", position_id=position_id, created_at=now))
|
||||
for skill_name, row in position_rows.items():
|
||||
if skill_name not in target:
|
||||
await session.delete(row)
|
||||
|
||||
async def _sync_tasks(self, session: AsyncSession, user_id: str, position_id: str | None) -> None:
|
||||
target = await self._resolve_materialized(user_id, "scheduled_task", session)
|
||||
rows = list((await session.execute(select(ScheduledTaskSubscriptionRow).where(ScheduledTaskSubscriptionRow.user_id == user_id))).scalars())
|
||||
|
||||
-1
@@ -247,7 +247,6 @@ class SkillStorage(ABC):
|
||||
extensions_config = ExtensionsConfig.from_file()
|
||||
for skill in skills:
|
||||
skill.enabled = extensions_config.is_skill_enabled(skill.name, skill.category)
|
||||
skill.always_on = extensions_config.is_skill_always_on(skill.name)
|
||||
except Exception as e:
|
||||
logger.warning("Failed to load extensions config: %s", e)
|
||||
|
||||
|
||||
Reference in new issue
Block a user