sync update from LAN repo (source master-nj @ 067eb808)

This commit is contained in:
gozeros committed 2026-11-10 14:04:09 +08:00
1 parent 1244fb1f2f
commit 1d5dd8fc90
182 files changed
+18973 -769

No files matched your search

@@ -0,0 +1,197 @@
"""User-owned analysis projects and immutable project/thread bindings."""
from __future__ import annotations
from copy import deepcopy
from datetime import UTC, datetime
from uuid import uuid4
from sqlalchemy import ForeignKey, String, Text, delete, select
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime, PortableJSON
MODES = frozenset({"qa", "strategy", "solution"})
CONFIG_FIELDS = frozenset({"agent_id", "report_config", "strategy_config"})
EDITABLE_FIELDS = frozenset({"name", "background", "knowledge_base_ids", "assistant_knowledge_base_ids"}) | CONFIG_FIELDS
class AnalysisProjectConfigRow(Base):
"""Additive table: upgrades do not alter existing project/thread tables."""
__tablename__ = "analysis_project_configs"
key: Mapped[str] = mapped_column(String(80), primary_key=True)
config: Mapped[dict] = mapped_column(PortableJSON(), default=dict)
class AnalysisProjectRow(Base):
__tablename__ = "analysis_projects"
id: Mapped[str] = mapped_column(String(36), primary_key=True)
user_id: Mapped[str] = mapped_column(String(255), index=True)
name: Mapped[str] = mapped_column(String(160))
mode: Mapped[str] = mapped_column(String(16))
background: Mapped[str] = mapped_column(Text, default="")
knowledge_base_ids: Mapped[list] = mapped_column(PortableJSON(), default=list)
assistant_knowledge_base_ids: Mapped[list] = mapped_column(PortableJSON(), default=list)
created_at: Mapped[datetime] = mapped_column(BeijingDateTime())
updated_at: Mapped[datetime] = mapped_column(BeijingDateTime())
class AnalysisProjectThreadRow(Base):
__tablename__ = "analysis_project_threads"
thread_id: Mapped[str] = mapped_column(String(64), primary_key=True)
project_id: Mapped[str] = mapped_column(ForeignKey("analysis_projects.id"), index=True)
created_at: Mapped[datetime] = mapped_column(BeijingDateTime())
def _dict(row):
data = row.to_dict()
for key in ("created_at", "updated_at"):
if isinstance(data.get(key), datetime):
data[key] = data[key].isoformat()
return deepcopy(data)
class AnalysisProjectStore:
"""SQL in persistent deployments; isolated in-memory fallback for memory mode.
Every public project operation requires an explicit owner. The unscoped
thread lookup is only for the Gateway's ownership and run-policy checks.
Mode has no update path, and bindings are separate from client-editable metadata.
"""
def __init__(self, session_factory=None):
self._sf = session_factory
self._projects: dict[str, dict] = {}
self._threads: dict[str, dict] = {}
self._configs: dict[str, dict] = {}
async def config_for(self, key: str) -> dict:
if not self._sf:
return deepcopy(self._configs.get(key, {}))
async with self._sf() as session:
row = await session.get(AnalysisProjectConfigRow, key)
return deepcopy(row.config) if row else {}
async def _enrich(self, project: dict | None) -> dict | None:
if project is None:
return None
return {
**project,
"agent_id": None,
"report_config": {},
"strategy_config": {},
**await self.config_for(f"project:{project['id']}"),
}
async def create(self, user_id: str, *, mode: str, **fields) -> dict:
if mode not in MODES or set(fields) - EDITABLE_FIELDS:
raise ValueError("Invalid project fields")
now = datetime.now(UTC)
row = AnalysisProjectRow(
id=str(uuid4()),
user_id=user_id,
mode=mode,
name=fields["name"],
background=fields.get("background", ""),
knowledge_base_ids=list(fields.get("knowledge_base_ids", [])),
assistant_knowledge_base_ids=list(fields.get("assistant_knowledge_base_ids", [])),
created_at=now,
updated_at=now,
)
if self._sf:
async with self._sf() as session:
session.add(row)
session.add(AnalysisProjectConfigRow(key=f"project:{row.id}", config={key: deepcopy(fields[key]) for key in CONFIG_FIELDS if key in fields}))
await session.commit()
else:
self._projects[row.id] = _dict(row)
self._configs[f"project:{row.id}"] = {key: deepcopy(fields[key]) for key in CONFIG_FIELDS if key in fields}
return await self._enrich(_dict(row))
async def list(self, user_id: str) -> list[dict]:
if not self._sf:
return [await self._enrich(deepcopy(p)) for p in sorted(self._projects.values(), key=lambda p: p["updated_at"], reverse=True) if p["user_id"] == user_id]
async with self._sf() as session:
result = await session.execute(select(AnalysisProjectRow).where(AnalysisProjectRow.user_id == user_id).order_by(AnalysisProjectRow.updated_at.desc()))
rows = [_dict(row) for row in result.scalars()]
return [await self._enrich(row) for row in rows]
async def get(self, project_id: str, user_id: str) -> dict | None:
if not self._sf:
row = self._projects.get(project_id)
return await self._enrich(deepcopy(row)) if row and row["user_id"] == user_id else None
async with self._sf() as session:
row = (await session.execute(select(AnalysisProjectRow).where(AnalysisProjectRow.id == project_id, AnalysisProjectRow.user_id == user_id))).scalar_one_or_none()
data = _dict(row) if row else None
return await self._enrich(data)
async def update(self, project_id: str, user_id: str, **fields) -> dict | None:
if set(fields) - EDITABLE_FIELDS:
raise ValueError("项目模式创建后不可更改")
if not self._sf:
row = self._projects.get(project_id)
if not row or row["user_id"] != user_id:
return None
row.update({key: deepcopy(value) for key, value in fields.items() if key not in CONFIG_FIELDS}, updated_at=datetime.now(UTC).isoformat())
self._configs.setdefault(f"project:{project_id}", {}).update({key: deepcopy(value) for key, value in fields.items() if key in CONFIG_FIELDS})
return await self._enrich(deepcopy(row))
async with self._sf() as session:
row = (await session.execute(select(AnalysisProjectRow).where(AnalysisProjectRow.id == project_id, AnalysisProjectRow.user_id == user_id).with_for_update())).scalar_one_or_none()
if row is None:
return None
for key, value in fields.items():
if key not in CONFIG_FIELDS:
setattr(row, key, deepcopy(value))
options = await session.get(AnalysisProjectConfigRow, f"project:{project_id}")
config = {**(options.config if options else {}), **{key: deepcopy(value) for key, value in fields.items() if key in CONFIG_FIELDS}}
await session.merge(AnalysisProjectConfigRow(key=f"project:{project_id}", config=config))
row.updated_at = datetime.now(UTC)
await session.commit()
data = _dict(row)
return await self._enrich(data)
async def bind_thread(self, project_id: str, user_id: str, thread_id: str, *, agent_id: str | None = None) -> None:
if await self.get(project_id, user_id) is None:
raise ValueError("Project not found")
row = AnalysisProjectThreadRow(thread_id=thread_id, project_id=project_id, created_at=datetime.now(UTC))
if not self._sf:
if thread_id in self._threads:
raise ValueError("Thread already bound")
self._threads[thread_id] = _dict(row)
self._configs[f"thread:{thread_id}"] = {"agent_id": agent_id}
return
async with self._sf() as session:
session.add(row)
session.add(AnalysisProjectConfigRow(key=f"thread:{thread_id}", config={"agent_id": agent_id}))
await session.commit()
async def project_for_thread(self, thread_id: str) -> dict | None:
if not self._sf:
binding = self._threads.get(thread_id)
return await self._enrich(deepcopy(self._projects.get(binding["project_id"]))) if binding else None
async with self._sf() as session:
row = (await session.execute(select(AnalysisProjectRow).join(AnalysisProjectThreadRow).where(AnalysisProjectThreadRow.thread_id == thread_id))).scalar_one_or_none()
data = _dict(row) if row else None
return await self._enrich(data)
async def thread_ids(self, project_id: str, user_id: str) -> list[str]:
if await self.get(project_id, user_id) is None:
return []
if not self._sf:
return [key for key, value in reversed(list(self._threads.items())) if value["project_id"] == project_id]
async with self._sf() as session:
return list((await session.execute(select(AnalysisProjectThreadRow.thread_id).where(AnalysisProjectThreadRow.project_id == project_id).order_by(AnalysisProjectThreadRow.created_at.desc()))).scalars())
async def unbind_failed_creation(self, thread_id: str) -> None:
if not self._sf:
self._threads.pop(thread_id, None)
self._configs.pop(f"thread:{thread_id}", None)
return
async with self._sf() as session:
await session.execute(delete(AnalysisProjectThreadRow).where(AnalysisProjectThreadRow.thread_id == thread_id))
await session.execute(delete(AnalysisProjectConfigRow).where(AnalysisProjectConfigRow.key == f"thread:{thread_id}"))
await session.commit()
@@ -241,6 +241,8 @@ class AssistantKnowledgeRepository:
) -> tuple[str, str]:
metadata = package.get("source") or {}
provider = str(metadata.get("provider") or metadata.get("type") or "").strip().casefold()
if provider == "file" and metadata.get("digest"):
return f"file:{metadata['digest']}", str(metadata.get("filename") or fallback_name)
if provider == "weknora":
source_key = str(
metadata.get("knowledge_base_id")
@@ -35,6 +35,7 @@ from deerflow.persistence.agents.model import (
AgentRow,
AgentSkillRow,
)
from deerflow.persistence.analysis_projects import AnalysisProjectConfigRow, AnalysisProjectRow, AnalysisProjectThreadRow
from deerflow.persistence.assistant_knowledge.model import (
AssistantKnowledgeBaseRow,
AssistantKnowledgeEntityContributionRow,
@@ -125,6 +126,7 @@ from deerflow.persistence.skill_knowledge.model import (
SkillKnowledgeSyncJobRow,
)
from deerflow.persistence.skills.model import SkillDisplayAdapterRow, SkillFavoriteRow, SkillRow
from deerflow.persistence.strategy_agent_roles.model import StrategyAgentRoleRow
from deerflow.persistence.tags.model import TagAssignmentRow, TagRow
from deerflow.persistence.task_buttons.model import TaskButtonRow
from deerflow.persistence.task_reports.model import TaskReportRow
@@ -149,6 +151,7 @@ from deerflow.persistence.workflow_runs.model import (
from deerflow.persistence.workflows.model import WorkflowDefinitionRow, WorkflowVersionRow
__all__ = [
"AnalysisProjectConfigRow",
"FeedbackRow",
"FixedQuestionRow",
"AgentExtrasRow",
@@ -159,6 +162,7 @@ __all__ = [
"BusinessMappingRow",
"AssistantKnowledgeBaseRow",
"AssistantKnowledgeSourceRow",
"AssistantKnowledgeVectorRow",
"AssistantKnowledgeImportJobRow",
"AssistantKnowledgeWikiPageRow",
"AssistantKnowledgeWikiRevisionRow",
@@ -254,9 +258,12 @@ __all__ = [
"SkillKnowledgeSnapshotRow",
"SkillKnowledgeSyncItemRow",
"SkillKnowledgeSyncJobRow",
"StrategyAgentRoleRow",
"TagAssignmentRow",
"TagRow",
"TaskButtonRow",
"AnalysisProjectRow",
"AnalysisProjectThreadRow",
"TaskCopTaskRow",
"TaskReportRow",
"EmbedSessionRow",
@@ -14,7 +14,7 @@ import json
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import select
from sqlalchemy import select, update
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.parallel_agent_tasks.model import ParallelAgentTaskRow
@@ -59,12 +59,7 @@ class ParallelAgentTaskRepository:
async def list_tasks(self, user_id: str, *, limit: int = 200) -> list[dict[str, Any]]:
"""列出当前用户的任务(轻量元信息,不含 messages,供历史列表)。"""
stmt = (
select(ParallelAgentTaskRow)
.where(ParallelAgentTaskRow.user_id == user_id)
.order_by(ParallelAgentTaskRow.updated_at.desc())
.limit(limit)
)
stmt = select(ParallelAgentTaskRow).where(ParallelAgentTaskRow.user_id == user_id).order_by(ParallelAgentTaskRow.updated_at.desc()).limit(limit)
async with self._sf() as session:
result = await session.execute(stmt)
return [self._to_dict(row, with_messages=False) for row in result.scalars()]
@@ -103,22 +98,40 @@ class ParallelAgentTaskRepository:
brief=_UNSET,
agents=_UNSET,
messages=_UNSET,
expected_updated_at: datetime | str | None = None,
) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(ParallelAgentTaskRow, task_id)
if row is None or row.user_id != user_id:
expected_revision = expected_updated_at
if isinstance(expected_revision, str):
try:
expected_revision = datetime.fromisoformat(expected_revision.replace("Z", "+00:00"))
except ValueError:
return None
values: dict[str, Any] = {"updated_at": datetime.now(UTC)}
if title is not _UNSET and title is not None:
values["title"] = str(title).strip()
if brief is not _UNSET:
values["brief"] = brief or None
if agents is not _UNSET:
values["agents"] = _dumps(agents)
if messages is not _UNSET:
values["messages"] = _dumps(messages)
async with self._sf() as session:
statement = update(ParallelAgentTaskRow).where(
ParallelAgentTaskRow.id == task_id,
ParallelAgentTaskRow.user_id == user_id,
)
if expected_revision is not None:
statement = statement.where(ParallelAgentTaskRow.updated_at == expected_revision)
result = await session.execute(statement.values(**values))
if result.rowcount != 1:
await session.rollback()
return None
if title is not _UNSET and title is not None:
row.title = str(title).strip()
if brief is not _UNSET:
row.brief = brief or None
if agents is not _UNSET:
row.agents = _dumps(agents)
if messages is not _UNSET:
row.messages = _dumps(messages)
row.updated_at = datetime.now(UTC)
await session.commit()
await session.refresh(row)
row = await session.get(ParallelAgentTaskRow, task_id)
if row is None:
return None
return self._to_dict(row)
async def delete_task(self, task_id: str, user_id: str) -> bool:
@@ -0,0 +1,24 @@
"""Global strategy-selection agent role registry."""
from __future__ import annotations
from deerflow.persistence.strategy_agent_roles.base import StrategyAgentRoleStore
from deerflow.persistence.strategy_agent_roles.memory import (
MemoryStrategyAgentRoleStore,
)
from deerflow.persistence.strategy_agent_roles.model import StrategyAgentRoleRow
from deerflow.persistence.strategy_agent_roles.sql import StrategyAgentRoleRepository
__all__ = [
"MemoryStrategyAgentRoleStore",
"StrategyAgentRoleRepository",
"StrategyAgentRoleRow",
"StrategyAgentRoleStore",
"make_strategy_agent_role_store",
]
def make_strategy_agent_role_store(session_factory):
if session_factory is None:
return MemoryStrategyAgentRoleStore()
return StrategyAgentRoleRepository(session_factory)
@@ -0,0 +1,39 @@
"""Abstract store for the global strategy-selection agent registry."""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any
class StrategyAgentRoleStore(ABC):
@abstractmethod
async def ensure_defaults(self, rows: list[dict[str, Any]]) -> int:
"""Insert missing default rows without re-enabling disabled angles."""
@abstractmethod
async def list_roles(self, *, include_disabled: bool) -> list[dict[str, Any]]:
raise NotImplementedError
@abstractmethod
async def get_role(self, agent_id: str) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def create_role(self, data: dict[str, Any]) -> dict[str, Any]:
raise NotImplementedError
@abstractmethod
async def update_role(
self,
agent_id: str,
*,
enabled: bool | None = None,
sort_order: int | None = None,
) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def delete_role(self, agent_id: str) -> bool:
"""Hard-delete a registry row for create rollback only."""
raise NotImplementedError
@@ -0,0 +1,114 @@
"""In-memory strategy-agent registry used by memory persistence and tests."""
from __future__ import annotations
import asyncio
from datetime import UTC, datetime
from typing import Any
from deerflow.persistence.strategy_agent_roles.base import StrategyAgentRoleStore
def _now() -> str:
return datetime.now(UTC).isoformat()
def _copy(row: dict[str, Any]) -> dict[str, Any]:
return dict(row)
class MemoryStrategyAgentRoleStore(StrategyAgentRoleStore):
def __init__(self) -> None:
self._rows: dict[str, dict[str, Any]] = {}
self._lock = asyncio.Lock()
async def ensure_defaults(self, rows: list[dict[str, Any]]) -> int:
inserted = 0
async with self._lock:
for source in rows:
agent_id = str(source["agent_id"])
existing = self._rows.get(agent_id)
if existing is not None:
# Canonical fixed roles are executable infrastructure, not
# administrator-managed lifecycle rows. Repair stale or
# manually-corrupted metadata on every bootstrap. Angle
# defaults deliberately retain their enabled/order state.
if bool(source.get("fixed", False)):
canonical = {
"category": str(source["category"]),
"fixed": True,
"enabled": bool(source.get("enabled", True)),
"sort_order": int(source.get("sort_order", 0)),
}
if any(existing.get(key) != value for key, value in canonical.items()):
existing.update(canonical)
existing["updated_at"] = _now()
continue
now = _now()
self._rows[agent_id] = {
"agent_id": agent_id,
"category": str(source["category"]),
"fixed": bool(source.get("fixed", False)),
"enabled": bool(source.get("enabled", True)),
"sort_order": int(source.get("sort_order", 0)),
"created_at": now,
"updated_at": now,
}
inserted += 1
return inserted
async def list_roles(self, *, include_disabled: bool) -> list[dict[str, Any]]:
async with self._lock:
rows = [_copy(row) for row in self._rows.values() if include_disabled or bool(row.get("enabled"))]
rows.sort(
key=lambda row: (
int(row.get("sort_order", 0)),
str(row.get("agent_id", "")),
)
)
return rows
async def get_role(self, agent_id: str) -> dict[str, Any] | None:
async with self._lock:
row = self._rows.get(agent_id)
return _copy(row) if row is not None else None
async def create_role(self, data: dict[str, Any]) -> dict[str, Any]:
agent_id = str(data["agent_id"])
async with self._lock:
if agent_id in self._rows:
raise ValueError(f"Strategy agent role '{agent_id}' already exists")
now = _now()
row = {
"agent_id": agent_id,
"category": str(data["category"]),
"fixed": bool(data.get("fixed", False)),
"enabled": bool(data.get("enabled", True)),
"sort_order": int(data.get("sort_order", 0)),
"created_at": now,
"updated_at": now,
}
self._rows[agent_id] = row
return _copy(row)
async def update_role(
self,
agent_id: str,
*,
enabled: bool | None = None,
sort_order: int | None = None,
) -> dict[str, Any] | None:
async with self._lock:
row = self._rows.get(agent_id)
if row is None:
return None
if enabled is not None:
row["enabled"] = bool(enabled)
if sort_order is not None:
row["sort_order"] = int(sort_order)
row["updated_at"] = _now()
return _copy(row)
async def delete_role(self, agent_id: str) -> bool:
async with self._lock:
return self._rows.pop(agent_id, None) is not None
@@ -0,0 +1,36 @@
"""Persistence model for the global strategy-selection agent registry."""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import Boolean, Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime
class StrategyAgentRoleRow(Base):
"""Classify folder-backed agents used by the strategy-selection workflow.
The agent's model, skills and SOUL remain authoritative in its normal
``config.yaml`` / ``SOUL.md`` files. This small global table owns only the
workflow classification and lifecycle flags. Keeping a disabled row (and
the underlying agent) protects saved projects that still reference it.
"""
__tablename__ = "strategy_agent_roles"
agent_id: Mapped[str] = mapped_column(String(64), primary_key=True)
category: Mapped[str] = mapped_column(String(16), nullable=False, index=True)
fixed: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
enabled: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True, server_default="1", index=True)
sort_order: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC))
updated_at: Mapped[datetime] = mapped_column(
BeijingDateTime(),
nullable=False,
default=lambda: datetime.now(UTC),
onupdate=lambda: datetime.now(UTC),
)
@@ -0,0 +1,141 @@
"""SQLAlchemy-backed global strategy-selection agent registry."""
from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import delete, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.strategy_agent_roles.base import StrategyAgentRoleStore
from deerflow.persistence.strategy_agent_roles.model import StrategyAgentRoleRow
def _to_dict(row: StrategyAgentRoleRow) -> dict[str, Any]:
return {
"agent_id": row.agent_id,
"category": row.category,
"fixed": row.fixed,
"enabled": row.enabled,
"sort_order": row.sort_order,
"created_at": row.created_at.isoformat() if isinstance(row.created_at, datetime) else row.created_at,
"updated_at": row.updated_at.isoformat() if isinstance(row.updated_at, datetime) else row.updated_at,
}
class StrategyAgentRoleRepository(StrategyAgentRoleStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
async def ensure_defaults(self, rows: list[dict[str, Any]]) -> int:
inserted = 0
for source in rows:
# Commit each of the small number of defaults independently. If
# two workers race on one primary key, rolling that save back must
# not also discard unrelated defaults inserted by this worker.
async with self._sf() as session:
agent_id = str(source["agent_id"])
existing = await session.get(StrategyAgentRoleRow, agent_id)
if existing is not None:
if bool(source.get("fixed", False)):
changed = False
canonical = {
"category": str(source["category"]),
"fixed": True,
"enabled": bool(source.get("enabled", True)),
"sort_order": int(source.get("sort_order", 0)),
}
for key, value in canonical.items():
if getattr(existing, key) != value:
setattr(existing, key, value)
changed = True
if changed:
existing.updated_at = datetime.now(UTC)
await session.commit()
continue
now = datetime.now(UTC)
session.add(
StrategyAgentRoleRow(
agent_id=agent_id,
category=str(source["category"]),
fixed=bool(source.get("fixed", False)),
enabled=bool(source.get("enabled", True)),
sort_order=int(source.get("sort_order", 0)),
created_at=now,
updated_at=now,
)
)
try:
await session.commit()
except IntegrityError:
# Another startup worker won this primary-key race.
await session.rollback()
continue
inserted += 1
return inserted
async def list_roles(self, *, include_disabled: bool) -> list[dict[str, Any]]:
stmt = select(StrategyAgentRoleRow)
if not include_disabled:
stmt = stmt.where(StrategyAgentRoleRow.enabled.is_(True))
stmt = stmt.order_by(
StrategyAgentRoleRow.sort_order.asc(),
StrategyAgentRoleRow.agent_id.asc(),
)
async with self._sf() as session:
result = await session.execute(stmt)
return [_to_dict(row) for row in result.scalars()]
async def get_role(self, agent_id: str) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(StrategyAgentRoleRow, agent_id)
return _to_dict(row) if row is not None else None
async def create_role(self, data: dict[str, Any]) -> dict[str, Any]:
now = datetime.now(UTC)
row = StrategyAgentRoleRow(
agent_id=str(data["agent_id"]),
category=str(data["category"]),
fixed=bool(data.get("fixed", False)),
enabled=bool(data.get("enabled", True)),
sort_order=int(data.get("sort_order", 0)),
created_at=now,
updated_at=now,
)
async with self._sf() as session:
session.add(row)
try:
await session.commit()
except IntegrityError as exc:
await session.rollback()
raise ValueError(f"Strategy agent role '{row.agent_id}' already exists") from exc
await session.refresh(row)
return _to_dict(row)
async def update_role(
self,
agent_id: str,
*,
enabled: bool | None = None,
sort_order: int | None = None,
) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(StrategyAgentRoleRow, agent_id)
if row is None:
return None
if enabled is not None:
row.enabled = bool(enabled)
if sort_order is not None:
row.sort_order = int(sort_order)
row.updated_at = datetime.now(UTC)
await session.commit()
await session.refresh(row)
return _to_dict(row)
async def delete_role(self, agent_id: str) -> bool:
async with self._sf() as session:
result = await session.execute(delete(StrategyAgentRoleRow).where(StrategyAgentRoleRow.agent_id == agent_id))
await session.commit()
return (result.rowcount or 0) > 0