Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

fix(backend): keep a deleted skill deleted (#15589)

Nicholas Tindle0f920ed39414
diff --git a/autogpt_platform/backend/backend/api/features/experts/routes.py b/autogpt_platform/backend/backend/api/features/experts/routes.py
index 2b7f269b29..ec8b69a90a 100644
--- a/autogpt_platform/backend/backend/api/features/experts/routes.py
+++ b/autogpt_platform/backend/backend/api/features/experts/routes.py
@@ -45,6 +45,7 @@ from backend.copilot.computer import (
)
from backend.copilot.config import ChatConfig
from backend.copilot.tools.e2b_sandbox import SandboxOwner, kill_expert_sandbox
+from backend.copilot.tools.skills import SkillVersionConflictError, SkillWriteLockError
from backend.util.exceptions import NotFoundError
logger = logging.getLogger(__name__)
@@ -549,6 +550,10 @@ async def update_expert_skills(
# A listing resolves to its name only inside update_skills, so this
# attach-and-remove contradiction can't be caught by the request model.
raise fastapi.HTTPException(status_code=400, detail=str(e))
+ except (SkillWriteLockError, SkillVersionConflictError) as e:
+ # Removing a skill could not be ordered with another write to the
+ # expert's skills; repeating the request is safe.
+ raise fastapi.HTTPException(status_code=409, detail=str(e))
@router.patch(
diff --git a/autogpt_platform/backend/backend/api/features/experts/routes_test.py b/autogpt_platform/backend/backend/api/features/experts/routes_test.py
index 11fb181a8d..75a0b92f7d 100644
--- a/autogpt_platform/backend/backend/api/features/experts/routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/experts/routes_test.py
@@ -42,6 +42,7 @@ from backend.api.features.experts.models import (
from backend.api.features.experts.routes import public_router, router
from backend.api.features.store.skill_model import MarketplaceSkill
from backend.api.rest_api import app as rest_app
+from backend.copilot.tools.skills import SkillWriteLockError
from backend.util.exceptions import ConflictError, NotFoundError
from backend.util.feature_flag import Flag
@@ -1175,6 +1176,21 @@ def test_update_expert_skills_returns_400_when_a_listing_is_also_removed(
assert "both attached and removed" in response.json()["detail"]
+def test_update_expert_skills_returns_409_when_a_removal_could_not_be_ordered(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ mocker.patch(
+ "backend.api.features.experts.routes.experts_db.update_skills",
+ new_callable=AsyncMock,
+ side_effect=SkillWriteLockError("held elsewhere; try again"),
+ )
+
+ response = client.put("/experts/expert-1/skills", json={"remove": ["SEO"]})
+
+ assert response.status_code == 409
+ assert "try again" in response.json()["detail"]
+
+
def test_update_expert_skills_rejects_a_name_both_added_and_removed(
mocker: pytest_mock.MockerFixture,
) -> None:
diff --git a/autogpt_platform/backend/backend/api/features/skill_learning/models.py b/autogpt_platform/backend/backend/api/features/skill_learning/models.py
index 34bb87cbb4..934ef25433 100644
--- a/autogpt_platform/backend/backend/api/features/skill_learning/models.py
+++ b/autogpt_platform/backend/backend/api/features/skill_learning/models.py
@@ -17,6 +17,7 @@ STATE_LABELS: dict[str, str] = {
"archived": "Archived",
"invalidated": "Archived (source unavailable)",
"stale": "Archived (stale)",
+ "deleted": "Deleted",
}
DISPOSITION_LABELS: dict[str, str] = {
diff --git a/autogpt_platform/backend/backend/api/features/skill_learning/routes.py b/autogpt_platform/backend/backend/api/features/skill_learning/routes.py
index 9ea9923c0a..f8cb297718 100644
--- a/autogpt_platform/backend/backend/api/features/skill_learning/routes.py
+++ b/autogpt_platform/backend/backend/api/features/skill_learning/routes.py
@@ -56,6 +56,7 @@ from backend.data import skill_learning as learning_data
from backend.data import skill_reviews as reviews_data
from backend.data import skill_use as use_data
from backend.data import skill_versions as versions_data
+from backend.data.skill_deletion import DELETED_STATE
from backend.data.skill_learning import owner_key_for
from backend.util.feature_flag import Flag, is_feature_enabled
@@ -243,6 +244,8 @@ async def get_skill_detail(
state, label = "paused", "Paused (learning)"
elif current is not None:
state, label = current.state, state_label(current.state)
+ elif head.deleted:
+ state, label = DELETED_STATE, state_label(DELETED_STATE)
else:
state, label = "candidate", state_label("candidate")
return SkillLearningDetail(
diff --git a/autogpt_platform/backend/backend/api/features/skill_learning/routes_test.py b/autogpt_platform/backend/backend/api/features/skill_learning/routes_test.py
index 510a691051..c034d1946f 100644
--- a/autogpt_platform/backend/backend/api/features/skill_learning/routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/skill_learning/routes_test.py
@@ -591,6 +591,33 @@ def test_detail_does_not_lose_current_version_behind_unpublished_history(
assert resp.json()["state"] == "ready"
+def test_detail_of_a_deleted_skill_says_deleted(store, test_user_id):
+ _, current = run(_publish(store, test_user_id))
+ run(
+ store.record_skill_deletion(
+ test_user_id,
+ expert_id=EXPERT,
+ skill_name="csv-import-checks",
+ expected_current_version_id=current.id,
+ behaviors=[],
+ actor_user_id=test_user_id,
+ )
+ )
+ resp = client.get(
+ "/skill-learning/skills/csv-import-checks", params={"expert_id": EXPERT}
+ )
+ assert resp.status_code == 200
+ body = resp.json()
+ assert (body["state"], body["state_label"]) == ("deleted", "Deleted")
+ assert body["current_version"] is None
+ marker, deleted = body["versions"]
+ assert (marker["origin_label"], marker["summary"]) == (
+ "Deleted by you",
+ f"Deleted v{current.version}",
+ )
+ assert (deleted["id"], deleted["state"]) == (current.id, "archived")
+
+
@pytest.mark.parametrize("payload", [{}, {"edited_body": ""}, {"edited_body": " "}])
def test_apply_edited_requires_an_edited_body(store, test_user_id, payload):
_, version = run(_publish(store, test_user_id))
diff --git a/autogpt_platform/backend/backend/api/features/skills/routes.py b/autogpt_platform/backend/backend/api/features/skills/routes.py
index 308284a257..4e959f1373 100644
--- a/autogpt_platform/backend/backend/api/features/skills/routes.py
+++ b/autogpt_platform/backend/backend/api/features/skills/routes.py
@@ -12,7 +12,7 @@ from fastapi import (
UploadFile,
)
from fastapi.concurrency import run_in_threadpool
-from starlette.status import HTTP_404_NOT_FOUND
+from starlette.status import HTTP_404_NOT_FOUND, HTTP_409_CONFLICT
from backend.api.features.experts import experts_db
from backend.api.features.skill_zip import (
@@ -34,6 +34,8 @@ from backend.copilot.tools.skills import (
SkillLimitError,
SkillNotFoundError,
SkillPackageError,
+ SkillVersionConflictError,
+ SkillWriteLockError,
delete_user_skill,
get_default_skill_with_body,
list_user_skill_files,
@@ -366,7 +368,8 @@ async def delete_copilot_skill(
Built-in defaults are not user-deletable — attempting to delete one
returns 400. Missing skills return 404 so the UI can reconcile a
- stale list.
+ stale list. 409 means the delete could not be ordered with another
+ change to the owner's skills; nothing was deleted, so try again.
"""
await _require_skill_owner(user_id, expert_id)
try:
@@ -377,4 +380,6 @@ async def delete_copilot_skill(
raise HTTPException(status_code=400, detail=str(exc))
except SkillNotFoundError as exc:
raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail=str(exc))
+ except (SkillWriteLockError, SkillVersionConflictError) as exc:
+ raise HTTPException(status_code=HTTP_409_CONFLICT, detail=str(exc))
return {"name": slug}
diff --git a/autogpt_platform/backend/backend/api/features/skills/routes_test.py b/autogpt_platform/backend/backend/api/features/skills/routes_test.py
index a0536ef77b..a032592f46 100644
--- a/autogpt_platform/backend/backend/api/features/skills/routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/skills/routes_test.py
@@ -21,6 +21,8 @@ from backend.copilot.tools.skills import (
SkillLimitError,
SkillNotFoundError,
SkillPackage,
+ SkillVersionConflictError,
+ SkillWriteLockError,
parse_skill_markdown,
render_skill_markdown,
)
@@ -170,6 +172,27 @@ def test_delete_copilot_skill_returns_404_when_missing(
assert response.status_code == 404
+ "error",
+ [
+ SkillWriteLockError("held; try again"),
+ SkillVersionConflictError("v1", "v2"),
+ ],
+)
+def test_delete_copilot_skill_returns_409_when_it_could_not_be_ordered(
+ mocker: pytest_mock.MockFixture, error: Exception
+) -> None:
+ """Nothing was deleted, so the UI can offer a retry."""
+
+ mocker.patch(
+ "backend.api.features.skills.routes.delete_user_skill",
+ AsyncMock(side_effect=error),
+ )
+
+ response = client.delete("/skills/busy")
+ assert response.status_code == 409
+
+
def test_read_copilot_skill_returns_user_body(
mocker: pytest_mock.MockFixture,
) -> None:
diff --git a/autogpt_platform/backend/backend/copilot/learning/_fake_store.py b/autogpt_platform/backend/backend/copilot/learning/_fake_store.py
index a87697aed6..61a1f00d33 100644
--- a/autogpt_platform/backend/backend/copilot/learning/_fake_store.py
+++ b/autogpt_platform/backend/backend/copilot/learning/_fake_store.py
@@ -15,6 +15,13 @@ from datetime import datetime, timezone
from typing import Any
from backend.data.skill_content_approvals import SkillContentApproval
+from backend.data.skill_deletion import (
+ DELETED_ORIGIN,
+ DELETED_REASON,
+ DELETED_STATE,
+ DeletedBehavior,
+ SkillDeletion,
+)
from backend.data.skill_learning import (
LearningAccessError,
LearningSourceRecord,
@@ -570,6 +577,22 @@ class FakeLearningStore:
self._put_head(head)
return head
+ async def pause_use_if_current(
+ self, user_id: str, head_id: str, version_id: str
+ ) -> bool:
+ head = next(
+ (
+ h
+ for h in self.heads.values()
+ if h.id == head_id and h.user_id == user_id
+ ),
+ None,
+ )
+ if head is None or head.current_version_id != version_id:
+ return False
+ self._put_head(head.model_copy(update={"use_paused_at": _now()}))
+ return True
+
# ---- versions ------------------------------------------------------
def _next_number(self, head_id: str) -> int:
@@ -951,6 +974,88 @@ class FakeLearningStore:
latest = max(rows, key=lambda v: v.version, default=None)
return latest.id if latest else None
+ # ---- deletion ------------------------------------------------------
+
+ async def record_skill_deletion(
+ self,
+ user_id: str,
+ *,
+ expert_id: str | None,
+ skill_name: str,
+ expected_current_version_id: str | None,
+ behaviors: list[DeletedBehavior],
+ actor_user_id: str | None,
+ ) -> SkillDeletion:
+ owner_key = owner_key_for(expert_id)
+ head = await self.get_head(user_id, owner_key, skill_name)
+ current_id = head.current_version_id if head is not None else None
+ if current_id != expected_current_version_id:
+ return SkillDeletion(committed=False)
+ for behavior in behaviors:
+ if not await self.find_suppression(
+ user_id, owner_key, skill_name, behavior.behavior_fingerprint
+ ):
+ await self.add_suppression(
+ user_id,
+ expert_id=expert_id,
+ skill_name=skill_name,
+ behavior_fingerprint=behavior.behavior_fingerprint,
+ behavior_tokens=behavior.behavior_tokens,
+ evidence_fingerprints=behavior.evidence_fingerprints,
+ actor_user_id=actor_user_id,
+ reason="deleted by the owner",
+ )
+ if head is None:
+ head = await self.ensure_head(user_id, expert_id, skill_name)
+ marker = await self.create_version(
+ user_id,
+ head=head,
+ content="",
+ description="",
+ triggers=[],
+ origin=DELETED_ORIGIN,
+ summary=f"Deleted v{head.current_version}" if current_id else "Deleted",
+ state=DELETED_STATE,
+ actor_user_id=actor_user_id,
+ )
+ self._put_head(
+ head.model_copy(
+ update={
+ "current_version": marker.version,
+ "current_version_id": None,
+ "content_hash": None,
+ "auto_improve": True,
+ "learning_paused_at": None,
+ "use_paused_at": None,
+ }
+ )
+ )
+ history = [
+ v
+ for v in self.versions.values()
+ if v.user_id == user_id and v.head_id == head.id
+ ]
+ pending = [v for v in history if v.state == PENDING_WRITE_STATE]
+ for version in pending:
+ await self.abandon_publication(
+ user_id,
+ version_id=version.id,
+ review_id=version.review_id,
+ reason=DELETED_REASON,
+ disposition="suppressed",
+ )
+ archived = [v.id for v in history if v.state in ("ready", "needs_decision")]
+ for version_id in archived:
+ await self.set_version_state(
+ user_id, version_id, "archived", DELETED_REASON
+ )
+ return SkillDeletion(
+ committed=True,
+ marker=marker,
+ archived_version_ids=archived,
+ abandoned_version_ids=[v.id for v in pending],
+ )
+
# ---- suppressions + use events -------------------------------------
async def add_suppression(
diff --git a/autogpt_platform/backend/backend/copilot/learning/accessors_test.py b/autogpt_platform/backend/backend/copilot/learning/accessors_test.py
index ef42c6d48e..1e49ac688d 100644
--- a/autogpt_platform/backend/backend/copilot/learning/accessors_test.py
+++ b/autogpt_platform/backend/backend/copilot/learning/accessors_test.py
@@ -9,6 +9,7 @@ import re
from pathlib import Path
from backend.data import (
+ skill_deletion,
skill_learning,
skill_publication,
skill_reviews,
@@ -19,7 +20,7 @@ from backend.data.db_manager import DatabaseManagerAsyncClient
_CALL_RE = re.compile(
r"(skill_learning_db|skill_reviews_db|skill_versions_db|skill_publication_db"
- r"|skill_use_db)\(\)\s*\.\s*(\w+)"
+ r"|skill_use_db|skill_deletion_db)\(\)\s*\.\s*(\w+)"
)
_ROOTS = (
Path(__file__).parent,
@@ -46,6 +47,7 @@ def test_every_accessor_call_is_exposed_on_the_rpc_client():
assert any(
hasattr(module, name)
for module in (
+ skill_deletion,
skill_learning,
skill_reviews,
skill_versions,
diff --git a/autogpt_platform/backend/backend/copilot/learning/deletion_test.py b/autogpt_platform/backend/backend/copilot/learning/deletion_test.py
new file mode 100644
index 0000000000..3deab6709b
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/learning/deletion_test.py
@@ -0,0 +1,366 @@
+"""Deleting a skill ends its history: neither a source revocation nor
+overnight learning brings the deleted skill back (#15540).
+
+The probe from the issue: an independent v1, a v2 learned from chat A, then
+the owner deletes the skill and excludes chat A. Revocation used to restore
+v1 as a new ready version and write the deleted skill back, and a learned
+``create`` for the name conflicted with the head for good.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from backend.copilot.tools import skills
+from backend.copilot.tools.skills import SkillFile
+from backend.copilot.tools.skills_test import _FakeWorkspaceManager, _patch_skills_path
+from backend.data.skill_publication import VersionDraft
+
+from . import owner_actions, publish, publish_test, revocation
+from ._fake_store import FakeLearningStore
+from .contract import register_source_adapter
+from .publish_test import BODY_V1, BODY_V2, KIND, NAME, USER, _Adapter, _content
+
+workspace = publish_test.workspace
+
+OWNER = "personal"
+NEAR_COPY = BODY_V2.replace(
+ "2. Validate the row count\n",
+ "2. Validate the row count\n3. Report the row count\n",
+)
+DIFFERENT = "## Steps\n1. Parse each line as JSON\n2. Drop duplicate ids\n"
+STOPWORDS_ONLY = "## Steps\n1. Use the\n2. And then\n"
+SCRIPT = b"print('rows match')\n"
+SCRIPT_PATH = f"/skills/{NAME}/scripts/check.py"
+
+
+def _snapshot(source) -> publish.SourceSnapshot:
+ return publish.SourceSnapshot(
+ source_id=source.id,
+ source_kind=source.source_kind,
+ source_ref=source.source_id,
+ revision=source.revision,
+ epoch=source.epoch,
+ )
+
+
+async def _commit(store: FakeLearningStore, body: str, origin: str, sources):
+ head = await store.ensure_head(USER, None, NAME)
+ result = await store.commit_version_safe(
+ USER,
+ head=head,
+ expected_current_version=head.current_version,
+ draft=VersionDraft(
+ content=_content(body),
+ description="Import a CSV",
+ triggers=["csv"],
+ origin=origin,
+ base_version_id=head.current_version_id,
+ sources=sources,
+ ),
+ )
+ await store.complete_publication(USER, version_id=result.version.id, review_id=None)
+ return result.version
+
+
+class _Skill:
+ """An independent v1 and a v2 learned from the ``withdrawn`` chat, with
+ v2 in the workspace."""
+
+ def __init__(self, store: FakeLearningStore, monkeypatch) -> None:
+ self.store = store
+ self.manager = _FakeWorkspaceManager()
+ self.manager.files[f"/skills/{NAME}/SKILL.md"] = _content(BODY_V2).encode()
+ monkeypatch.setattr(skills, "skill_versions_db", lambda: store)
+ monkeypatch.setattr(skills, "skill_deletion_db", lambda: store)
+
+ async def seed(self, *, independent: bool = True, learned: bool = True) -> None:
+ register_source_adapter(_Adapter(self.store))
+ self.withdrawn, self.later = [
+ await self.store.upsert_source_revision(
+ USER,
+ expert_id=None,
+ source_kind=KIND,
+ source_id=ref,
+ revision="1",
+ evidence_refs=[],
+ outcome_signals=[],
+ )
+ for ref in ("withdrawn", "later")
+ ]
+ if independent:
+ self.independent = await _commit(self.store, BODY_V1, "edited", [])
+ if learned:
+ self.learned = await _commit(
+ self.store,
+ BODY_V2,
+ "saved_overnight",
+ [_snapshot(self.withdrawn).as_dependency()],
+ )
+
+ async def delete(self) -> None:
+ with _patch_skills_path(self.manager):
+ await skills.delete_user_skill(USER, NAME)
+
+ async def exclude_withdrawn(self) -> list[str]:
+ excluded = await self.store.set_source_eligibility(
+ USER, self.withdrawn.id, "excluded", excluded_by_user_id=USER
+ )
+ return await revocation.invalidate_versions_for_source(
+ USER, excluded, "source excluded"
+ )
+
+
+async def test_excluding_a_source_of_a_deleted_skill_does_not_bring_it_back(
+ fake_store, workspace, monkeypatch
+):
+ skill = _Skill(fake_store, monkeypatch)
+ await skill.seed()
+ await skill.delete()
+
+ assert await skill.exclude_withdrawn() == [skill.learned.id]
+
+ head = await fake_store.get_head(USER, OWNER, NAME)
+ assert head.current_version_id is None
+ assert await fake_store.latest_independent_version_id(USER, head.id) is None
+ states = {
+ v.version: v.state for v in await fake_store.list_versions(USER, OWNER, NAME)
+ }
+ assert states == {1: "archived", 2: "invalidated", 3: "deleted"}
+ workspace.assert_not_awaited()
+ assert f"/skills/{NAME}/SKILL.md" not in skill.manager.files
+
+
+async def test_a_delete_landing_mid_revocation_is_not_undone(
+ fake_store, workspace, monkeypatch
+):
+ """Revocation reads the head, then restores; a delete in between wins."""
+ skill = _Skill(fake_store, monkeypatch)
+ await skill.seed()
+ restore = owner_actions.restore_version
+
+ async def delete_then_restore(**kwargs):
+ await skill.delete()
+ return await restore(**kwargs)
+
+ monkeypatch.setattr(revocation, "restore_version", delete_then_restore)
+
+ await skill.exclude_withdrawn()
+
+ head = await fake_store.get_head(USER, OWNER, NAME)
+ assert head.current_version_id is None
+ workspace.assert_not_awaited()
+
+
+ ("body", "status"),
+ [(BODY_V2, "suppressed"), (NEAR_COPY, "needs_decision"), (DIFFERENT, "applied")],
+ ids=["same", "near-copy", "different"],
+)
+async def test_learning_brings_back_only_something_different(
+ fake_store, workspace, monkeypatch, body, status
+):
+ skill = _Skill(fake_store, monkeypatch)
+ await skill.seed()
+ await skill.delete()
+ monkeypatch.setattr(
+ publish, "read_user_skill_markdown", AsyncMock(return_value=None)
+ )
+
+ outcome = await publish.publish_learned_version(
+ publish.PublishRequest(
+ user_id=USER,
+ expert_id=None,
+ skill_name=NAME,
+ description="Import a CSV",
+ triggers=["csv"],
+ body=body,
+ summary="Learned again",
+ origin="saved_overnight",
+ sources=[_snapshot(skill.later)],
+ create_only=True,
+ )
+ )
+
+ assert outcome.status == status
+ head = await fake_store.get_head(USER, OWNER, NAME)
+ if status == "suppressed":
+ assert outcome.version is None
+ assert head.current_version_id is None
+ return
+ # A new chain: nothing links it to the deleted history, so revoking a
+ # source of that history can never reach it.
+ assert outcome.version.base_version_id is None
+ assert (head.current_version_id == outcome.version.id) == (status == "applied")
+ assert await skill.exclude_withdrawn() == [skill.learned.id]
+ after = await fake_store.get_head(USER, OWNER, NAME)
+ assert after.current_version_id == head.current_version_id
+
+
+def _request(body: str, **kwargs) -> publish.PublishRequest:
+ return publish.PublishRequest(
+ user_id=USER,
+ expert_id=None,
+ skill_name=NAME,
+ description="Import a CSV",
+ triggers=["csv"],
+ body=body,
+ summary="Learned again",
+ origin="saved_overnight",
+ **kwargs,
+ )
+
+
+async def test_a_run_that_read_the_package_before_the_delete_does_not_import_it(
+ fake_store, workspace, monkeypatch
+):
+ skill = _Skill(fake_store, monkeypatch)
+ await skill.seed()
+ await skill.delete()
+ monkeypatch.setattr(
+ publish,
+ "read_user_skill_markdown",
+ AsyncMock(return_value=_content(BODY_V2)),
+ )
+
+ outcome = await publish.publish_learned_version(
+ _request(DIFFERENT, sources=[_snapshot(skill.later)])
+ )
+
+ assert outcome.status == "conflict"
+ assert (await fake_store.get_head(USER, OWNER, NAME)).deleted
+ origins = [v.origin for v in await fake_store.list_versions(USER, OWNER, NAME)]
+ assert "imported" not in origins
+ workspace.assert_not_awaited()
+
+
+async def test_an_import_that_loses_to_a_deletion_records_nothing(
+ fake_store, workspace, monkeypatch
+):
+ """A skill saved before version history is imported before learning
+ changes it. A deletion landing between the run's read and the import's
+ commit wins: the stale bytes are not imported over it."""
+ monkeypatch.setattr(
+ publish,
+ "read_user_skill_markdown",
+ AsyncMock(return_value=_content(BODY_V1)),
+ )
+ commit = fake_store.commit_version_safe
+
+ async def delete_first(*args, **kwargs):
+ monkeypatch.setattr(fake_store, "commit_version_safe", commit)
+ await fake_store.record_skill_deletion(
+ USER,
+ expert_id=None,
+ skill_name=NAME,
+ expected_current_version_id=None,
+ behaviors=[],
+ actor_user_id=USER,
+ )
+ return await commit(*args, **kwargs)
+
+ monkeypatch.setattr(fake_store, "commit_version_safe", delete_first)
+
+ outcome = await publish.publish_learned_version(_request(BODY_V2))
+
+ assert outcome.status == "write_failed"
+ assert (await fake_store.get_head(USER, OWNER, NAME)).deleted
+ origins = [v.origin for v in await fake_store.list_versions(USER, OWNER, NAME)]
+ assert origins == ["deleted"]
+ workspace.assert_not_awaited()
+
+
+async def test_a_delete_landing_mid_revocation_is_not_paused(
+ fake_store, workspace, monkeypatch
+):
+ """With no version to fall back to, revocation pauses the skill. A delete
+ landing between its read and the pause must not inherit the pause, or a
+ later skill under the name would start out hidden."""
+ skill = _Skill(fake_store, monkeypatch)
+ await skill.seed(independent=False)
+ fallback = fake_store.latest_independent_version_id
+
+ async def delete_then_look(*args, **kwargs):
+ await skill.delete()
+ return await fallback(*args, **kwargs)
+
+ monkeypatch.setattr(fake_store, "latest_independent_version_id", delete_then_look)
+
+ await skill.exclude_withdrawn()
+
+ head = await fake_store.get_head(USER, OWNER, NAME)
+ assert head.deleted
+ assert head.use_paused_at is None
+
+
+def _script() -> SkillFile:
+ return SkillFile(relative_path="scripts/check.py", content=SCRIPT)
+
+
+async def test_the_deleted_package_with_its_files_is_suppressed(
+ fake_store, workspace, monkeypatch
+):
+ skill = _Skill(fake_store, monkeypatch)
+ skill.manager.files[SCRIPT_PATH] = SCRIPT
+ await skill.seed()
+ await skill.delete()
+ monkeypatch.setattr(
+ publish, "read_user_skill_markdown", AsyncMock(return_value=None)
+ )
+
+ outcome = await publish.publish_learned_version(
+ _request(
+ BODY_V2,
+ files=[_script()],
+ sources=[_snapshot(skill.later)],
+ create_only=True,
+ )
+ )
+
+ assert outcome.status == "suppressed"
+
+
+async def test_a_package_unreadable_at_deletion_still_needs_the_owner(
+ fake_store, workspace, monkeypatch
+):
+ """If the package's files cannot be read when it is deleted, its body
+ alone is recorded. The same package proposed again then waits for the
+ owner, even when its steps are all stopwords."""
+ skill = _Skill(fake_store, monkeypatch)
+ skill.manager.files[f"/skills/{NAME}/SKILL.md"] = _content(STOPWORDS_ONLY).encode()
+ skill.manager.files[SCRIPT_PATH] = SCRIPT
+ await skill.seed(independent=False, learned=False)
+ read = skill.manager.read_file
+
+ async def lose_the_script(path: str) -> bytes:
+ if path == SCRIPT_PATH:
+ raise OSError("blob missing")
+ return await read(path)
+
+ monkeypatch.setattr(skill.manager, "read_file", lose_the_script)
+ await skill.delete()
+ monkeypatch.setattr(
+ publish, "read_user_skill_markdown", AsyncMock(return_value=None)
+ )
+
+ outcome = await publish.publish_learned_version(
+ _request(
+ STOPWORDS_ONLY,
+ files=[_script()],
+ sources=[_snapshot(skill.later)],
+ create_only=True,
+ )
+ )
+
+ assert outcome.status == "needs_decision"
+ workspace.assert_not_awaited()
diff --git a/autogpt_platform/backend/backend/copilot/learning/fingerprint.py b/autogpt_platform/backend/backend/copilot/learning/fingerprint.py
index 7956caf778..3a7842b103 100644
--- a/autogpt_platform/backend/backend/copilot/learning/fingerprint.py
+++ b/autogpt_platform/backend/backend/copilot/learning/fingerprint.py
@@ -61,8 +61,15 @@ def behavior_fingerprint(
def token_overlap(a: list[str], b: list[str]) -> float:
- """Jaccard overlap of two token bags (0 when either is empty)."""
+ """Jaccard overlap of two token bags.
+
+ Two empty bags are identical (1.0): a procedure whose steps are all
+ stopwords must still match its own suppression. An empty bag against a
+ non-empty one is 0.
+ """
left, right = set(a), set(b)
+ if not left and not right:
+ return 1.0
if not left or not right:
return 0.0
return len(left & right) / len(left | right)
diff --git a/autogpt_platform/backend/backend/copilot/learning/fingerprint_test.py b/autogpt_platform/backend/backend/copilot/learning/fingerprint_test.py
index 3a427b58ae..33a61bc1f5 100644
--- a/autogpt_platform/backend/backend/copilot/learning/fingerprint_test.py
+++ b/autogpt_platform/backend/backend/copilot/learning/fingerprint_test.py
@@ -55,3 +55,12 @@ def test_empty_bullets_do_not_hide_a_prose_procedure() -> None:
prose = "Validate record counts before importing."
padded = "* " + " " * 100_000 + "\n" + prose
assert behavior_tokens(padded) == behavior_tokens(prose)
+
+
+def test_two_procedures_of_only_stopwords_overlap_fully() -> None:
+ """A suppressed procedure whose steps are all stopwords must still match
+ itself; against real content it matches nothing."""
+ empty = behavior_tokens("1. Use the\n2. And then")
+ assert empty == []
+ assert token_overlap(empty, behavior_tokens("1. And then\n2. Use the")) == 1.0
+ assert token_overlap(empty, behavior_tokens("1. Validate the row count")) == 0.0
diff --git a/autogpt_platform/backend/backend/copilot/learning/history.py b/autogpt_platform/backend/backend/copilot/learning/history.py
index 072f52ac02..558e9fc04a 100644
--- a/autogpt_platform/backend/backend/copilot/learning/history.py
+++ b/autogpt_platform/backend/backend/copilot/learning/history.py
@@ -42,6 +42,7 @@ async def record_registry_write(
keep_auto_improve: bool | None,
files: list[SkillVersionFile] | None = None,
content_approvals: list[SkillContentApproval] | None = None,
+ only_if_head_at: int | None = None,
) -> SkillVersionRecord | None:
"""Append the version for a workspace write that already succeeded.
@@ -49,10 +50,17 @@ async def record_registry_write(
is the truth of what the file now says; a concurrent automated commit
that loses the race is superseded by the human write, never the other
way round. Never raises — history must not fail the write it records.
+
+ ``only_if_head_at`` is for bytes read earlier without the write lock: a
+ single compare-and-swap against that head position, no retry. If the
+ head has moved since (a deletion, or any other write), the bytes are
+ stale and nothing is recorded.
"""
try:
versions = skill_versions_db()
head = await versions.ensure_head(user_id, expert_id, skill_name)
+ if only_if_head_at is not None and head.current_version != only_if_head_at:
+ return None
if head.content_hash == content_hash(rendered) and head.current_version_id:
current = await versions.get_version(user_id, head.current_version_id)
if (
@@ -69,7 +77,7 @@ async def record_registry_write(
):
return None
auto_improve = _auto_improve_after(origin, keep_auto_improve)
- for _ in range(3):
+ for _ in range(3 if only_if_head_at is None else 1):
result = await skill_publication_db().commit_version_safe(
user_id,
head=head,
diff --git a/autogpt_platform/backend/backend/copilot/learning/owner_actions.py b/autogpt_platform/backend/backend/copilot/learning/owner_actions.py
index 30a4074e4f..4cdc1a35d3 100644
--- a/autogpt_platform/backend/backend/copilot/learning/owner_actions.py
+++ b/autogpt_platform/backend/backend/copilot/learning/owner_actions.py
@@ -129,6 +129,7 @@ async def restore_version(
actor_user_id: str,
reason: str = "Restored by the owner",
suppress_behavior: bool = True,
+ replacing_version_id: str | None = None,
) -> PublishOutcome:
"""Restore prior content as a new version, suppressing owner-rejected behavior.
@@ -136,7 +137,9 @@ async def restore_version(
one), affects future use only, and — as the first-release boundary —
turns automatic improvements off for the skill so the undone change
cannot reappear without an explicit decision. Source revocation skips
- behavior suppression because it withdraws evidence, not the procedure.
+ behavior suppression because it withdraws evidence, not the procedure,
+ and passes ``replacing_version_id``: the version it read as current, so
+ a skill deleted or changed since that read is left alone.
"""
versions = skill_versions_db()
target = await versions.get_version(user_id, version_id)
@@ -156,6 +159,13 @@ async def restore_version(
head = await versions.get_head(user_id, owner_key_for(expert_id), skill_name)
if head is None:
return PublishOutcome(status="conflict", reason="skill has no version history")
+ if (
+ replacing_version_id is not None
+ and head.current_version_id != replacing_version_id
+ ):
+ return PublishOutcome(
+ status="conflict", reason="the skill changed before it could be restored"
+ )
replaced = (
await versions.get_version(user_id, head.current_version_id)
if head.current_version_id
diff --git a/autogpt_platform/backend/backend/copilot/learning/publish.py b/autogpt_platform/backend/backend/copilot/learning/publish.py
index c087219754..8570468e80 100644
--- a/autogpt_platform/backend/backend/copilot/learning/publish.py
+++ b/autogpt_platform/backend/backend/copilot/learning/publish.py
@@ -205,6 +205,12 @@ async def publish_learned_version(request: PublishRequest) -> PublishOutcome:
return PublishOutcome(
status="conflict", reason="the target skill already has a version"
)
+ if head.deleted and current_text is not None:
+ # This run read the package before its owner deleted it; importing
+ # those bytes now would bring the deleted skill back.
+ return PublishOutcome(
+ status="conflict", reason="the skill was deleted after it was read"
+ )
if head.current_version_id is None and current is not None and current_text:
await record_registry_write(
request.user_id,
@@ -218,6 +224,7 @@ async def publish_learned_version(request: PublishRequest) -> PublishOutcome:
summary="Existing skill preserved before learning",
keep_auto_improve=False,
files=snapshot_files(current_files),
+ only_if_head_at=head.current_version,
)
head = await versions.ensure_head(
request.user_id, request.expert_id, request.skill_name
diff --git a/autogpt_platform/backend/backend/copilot/learning/retrieval.py b/autogpt_platform/backend/backend/copilot/learning/retrieval.py
index 64c861223a..4d19a27e02 100644
--- a/autogpt_platform/backend/backend/copilot/learning/retrieval.py
+++ b/autogpt_platform/backend/backend/copilot/learning/retrieval.py
@@ -29,12 +29,13 @@ ORIGIN_LABELS = {
"edited": "Edited by owner",
"restored": "Restored by owner",
"imported": "Imported",
+ "deleted": "Deleted by owner",
}
def origin_label(origin: str, *, viewer_is_actor: bool = False) -> str:
label = ORIGIN_LABELS.get(origin, origin.replace("_", " ").capitalize())
- if viewer_is_actor and origin in ("requested", "edited", "restored"):
+ if viewer_is_actor and origin in ("requested", "edited", "restored", "deleted"):
return label.replace("by user", "by you").replace("by owner", "by you")
return label
diff --git a/autogpt_platform/backend/backend/copilot/learning/revocation.py b/autogpt_platform/backend/backend/copilot/learning/revocation.py
index 56179222ae..e30507c13a 100644
--- a/autogpt_platform/backend/backend/copilot/learning/revocation.py
+++ b/autogpt_platform/backend/backend/copilot/learning/revocation.py
@@ -25,13 +25,14 @@ async def invalidate_versions_for_source(
heads_touched = {(v.owner_key, v.skill_name, v.expert_id) for v in affected}
for owner_key, skill_name, expert_id in heads_touched:
head = await versions.get_head(user_id, owner_key, skill_name)
- if head is None or head.current_version_id not in affected_ids:
+ replaced = head.current_version_id if head is not None else None
+ if head is None or replaced is None or replaced not in affected_ids:
continue
fallback = await versions.latest_independent_version_id(user_id, head.id)
if fallback is None:
- await versions.update_head_policy(
- user_id, owner_key, skill_name, use_paused=True
- )
+ # Conditional: a deletion (or a newer version) landing since the
+ # head was read must not inherit this pause.
+ await versions.pause_use_if_current(user_id, head.id, replaced)
await invalidate_skills_index_cache(user_id, expert_id)
continue
await restore_version(
@@ -42,6 +43,7 @@ async def invalidate_versions_for_source(
actor_user_id=user_id,
reason="Restored after a source became unavailable",
suppress_behavior=False,
+ replacing_version_id=replaced,
)
await invalidate_skills_index_cache(user_id, expert_id)
return [v.id for v in affected]
diff --git a/autogpt_platform/backend/backend/copilot/tools/conftest.py b/autogpt_platform/backend/backend/copilot/tools/conftest.py
index 93535f485f..53ec890f6c 100644
--- a/autogpt_platform/backend/backend/copilot/tools/conftest.py
+++ b/autogpt_platform/backend/backend/copilot/tools/conftest.py
@@ -80,6 +80,7 @@ def stub_learning_registry(monkeypatch):
"backend.copilot.learning.history.skill_versions_db",
"backend.copilot.learning.history.skill_publication_db",
"backend.copilot.tools.skills.skill_versions_db",
+ "backend.copilot.tools.skills.skill_deletion_db",
):
monkeypatch.setattr(target, lambda: store)
return store
diff --git a/autogpt_platform/backend/backend/copilot/tools/skills.py b/autogpt_platform/backend/backend/copilot/tools/skills.py
index 91debab9c0..afe41ec274 100644
--- a/autogpt_platform/backend/backend/copilot/tools/skills.py
+++ b/autogpt_platform/backend/backend/copilot/tools/skills.py
@@ -43,6 +43,11 @@ from backend.copilot.learning.content_checks import (
check_skill_bundle,
collect_content_approvals,
)
+from backend.copilot.learning.fingerprint import (
+ behavior_fingerprint,
+ behavior_tokens,
+ evidence_fingerprint,
+)
from backend.copilot.learning.history import record_registry_write
from backend.copilot.learning.retrieval import (
mark_index_revision_seen,
@@ -57,6 +62,7 @@ from backend.copilot.service import SKILLS_UPDATE_TAG, strip_server_injected_tag
from backend.data.db_accessors import (
experts_db,
skill_db,
+ skill_deletion_db,
skill_versions_db,
workspace_db,
)
@@ -71,6 +77,7 @@ from backend.data.skill_capacity import SkillLimitError, SkillOwnedError
from backend.data.skill_capacity import normalize_skill_origin as _normalize_origin
from backend.data.skill_capacity import skill_name_key
from backend.data.skill_content_approvals import SkillContentApproval
+from backend.data.skill_deletion import DeletedBehavior
from backend.data.skill_learning import owner_key_for
from backend.data.skill_package import (
SKILL_MD,
@@ -80,7 +87,7 @@ from backend.data.skill_package import (
package_tree_sha256,
)
from backend.data.skill_version_files import SkillVersionFile
-from backend.data.skill_versions import content_hash
+from backend.data.skill_versions import SkillVersionRecord, content_hash
from backend.data.workspace_scope import (
EXPERT_SKILL_SCOPE_DENIED,
WorkspaceAccessDeniedError,
@@ -727,14 +734,20 @@ async def delete_user_skill(
(personal Otto's when ``None``).
The whole tree goes, however many files it holds — a package written
- before the cap existed still has to be removable. Returns the normalised
- slug on success so callers can echo it back.
+ before the cap existed still has to be removable. Before any file goes,
+ and under the per-owner write lock, the skill's version history is ended
+ and the deleted behaviour suppressed (:func:`_record_deletion`), so
+ neither a source revocation nor overnight learning brings it back.
+ Returns the normalised slug on success so callers can echo it back.
Raises :class:`BuiltInSkillError` for default skills,
- :class:`SkillNotFoundError` if the skill does not exist, and
- ``ValueError`` if ``name`` is blank. Sibling-file cleanup is
- best-effort — a transient delete failure on a non-SKILL.md file logs
- but does not abort the overall delete (the SKILL.md removal is what
- makes the skill disappear from ``<available_skills>``).
+ :class:`SkillNotFoundError` if the skill does not exist, ``ValueError``
+ if ``name`` is blank, and :class:`SkillWriteLockError` or
+ :class:`SkillVersionConflictError` when the delete could not be ordered
+ with other writes to the owner's skills; nothing was deleted then.
+ Sibling-file cleanup is best-effort — a transient delete failure on a
+ non-SKILL.md file logs but does not abort the overall delete (the
+ SKILL.md removal is what makes the skill disappear from
+ ``<available_skills>``).
"""
slug = name.strip().lower()
if not slug:
@@ -743,6 +756,30 @@ async def delete_user_skill(
raise BuiltInSkillError(f"'{slug}' is a built-in skill and cannot be deleted")
manager = await _get_user_skill_manager(user_id, scope)
+ lock = await _acquire_skill_write_lock(user_id, expert_id)
+ if lock is None:
+ raise SkillWriteLockError(
+ "could not order the delete with other changes to these skills; "
+ "try again"
+ )
+ try:
+ await _delete_skill_files(user_id, slug, expert_id, manager, lock)
+ finally:
+ await _release_skill_write_lock(lock, user_id)
+ await invalidate_skills_index_cache(user_id, expert_id)
+ if expert_id is not None:
+ await experts_db().remove_expert_skill_name(user_id, expert_id, slug)
+ return slug
+
+
+async def _delete_skill_files(
+ user_id: str,
+ slug: str,
+ expert_id: str | None,
+ manager: WorkspaceManager,
+ lock: AsyncClusterLock,
+) -> None:
+ """The delete itself; the caller holds the write lock."""
info = await manager.get_file_info_by_path(_skill_md_path(slug, expert_id))
if info is None:
if expert_id is not None:
@@ -753,29 +790,20 @@ async def delete_user_skill(
# Audit-log the delete BEFORE the workspace mutation runs so the
# log row is present even if the delete itself raises mid-cleanup.
- # Decode best-effort: a malformed body is fine for the audit trail —
- # the slug + truncated description is what an operator needs to
- # correlate later support requests.
- description_for_log = ""
- try:
- raw = await manager.read_file(_skill_md_path(slug, expert_id))
- try:
- text = raw.decode("utf-8")
- except UnicodeDecodeError:
- text = ""
- if text:
- parsed = parse_skill_markdown(text, fallback_name=slug)
- if parsed is not None:
- description_for_log = parsed.description
- except Exception:
- # Audit-log enrichment is best-effort; failure must not block the
- # delete the user requested.
- pass
+ # The description is best-effort — the slug + truncated description is
+ # what an operator needs to correlate later support requests.
+ parsed = await _read_deleted_skill(manager, slug, expert_id)
logger.info(
"[skills] user %s… deleting skill %s: %s",
user_id[:8],
slug,
- description_for_log[:60],
+ (parsed.description if parsed else "")[:60],
+ )
+ await _record_deletion(
+ user_id,
+ expert_id,
+ slug,
+ await _package_behavior(manager, expert_id, slug, parsed),
)
await manager.delete_file(info.id)
@@ -786,6 +814,16 @@ async def delete_user_skill(
# it rather than spinning it.
attempted: set[str] = set()
while True:
+ if not await lock.refresh():
+ # A writer that took the lock over may have just stored a package
+ # in this folder; leftover files are the lesser harm.
+ logger.warning(
+ "[skills] lost the write lock deleting %s for user %s — "
+ "leaving any remaining files",
+ slug,
+ user_id[:8],
+ )
+ break
try:
siblings = await _list_package_files(manager, skill_folder(expert_id), slug)
except Exception:
@@ -803,10 +841,123 @@ async def delete_user_skill(
sibling.path,
exc_info=True,
)
- await invalidate_skills_index_cache(user_id, expert_id)
- if expert_id is not None:
- await experts_db().remove_expert_skill_name(user_id, expert_id, slug)
- return slug
+
+
+async def _read_deleted_skill(
+ manager: WorkspaceManager, slug: str, expert_id: str | None
+) -> ParsedSkill | None:
+ try:
+ raw = await manager.read_file(_skill_md_path(slug, expert_id))
+ return parse_skill_markdown(raw.decode("utf-8"), fallback_name=slug)
+ except Exception:
+ # Reading is best-effort; failure must not block the delete the
+ # user requested.
+ return None
+
+
+async def _record_deletion(
+ user_id: str,
+ expert_id: str | None,
+ slug: str,
+ deleted: DeletedBehavior | None,
+) -> None:
+ """End *slug*'s version history and suppress what is being deleted.
+
+ Both the package as it stands and the version the head names are
+ suppressed: learning never reapplies either, a near copy becomes a
+ decision for the owner, and a different skill may still be learned
+ under the name. Phase 1 of a publication takes no write lock, so the
+ head can move between this read and the transaction; it is read again
+ a few times before the delete gives up.
+ """
+ versions = skill_versions_db()
+ current_id: str | None = None
+ for _ in range(3):
+ head = await versions.get_head(user_id, owner_key_for(expert_id), slug)
+ current_id = head.current_version_id if head is not None else None
+ current = (
+ await versions.get_version(user_id, current_id) if current_id else None
+ )
+ behaviors = {
+ b.behavior_fingerprint: b
+ for b in (deleted, _version_behavior(current))
+ if b is not None
+ }
+ result = await skill_deletion_db().record_skill_deletion(
+ user_id,
+ expert_id=expert_id,
+ skill_name=slug,
+ expected_current_version_id=current_id,
+ behaviors=list(behaviors.values()),
+ actor_user_id=user_id,
+ )
+ if result.committed:
+ return
+ raise SkillVersionConflictError(current_id, None)
+
+
+async def _package_behavior(
+ manager: WorkspaceManager,
+ expert_id: str | None,
+ slug: str,
+ parsed: ParsedSkill | None,
+) -> DeletedBehavior | None:
+ """The behaviour of the package being deleted, as learning would
+ fingerprint a proposal of it."""
+ if parsed is None:
+ return None
+ try:
+ files = await _read_package_files(
+ manager, skill_folder(expert_id), slug, complete=True
+ )
+ except Exception:
+ # Over the files cap, or a file that cannot be read. The body alone
+ # still catches the procedure: an exact copy then becomes a decision
+ # for the owner instead of being suppressed outright. Refusing the
+ # delete instead would leave a package with a lost file undeletable.
+ logger.warning(
+ "[skills] could not read the files of %s to record its deletion",
+ slug,
+ exc_info=True,
+ )
+ files = []
+ return _deleted_behavior(
+ slug,
+ parsed.body,
+ [
+ SkillVersionFile.from_content(f.relative_path, f.content, f.is_executable)
+ for f in files
+ ],
+ )
+
+
+def _version_behavior(version: SkillVersionRecord | None) -> DeletedBehavior | None:
+ if version is None or not version.content:
+ return None
+ parsed = parse_skill_markdown(version.content, fallback_name=version.skill_name)
+ if parsed is None:
+ return None
+ return _deleted_behavior(
+ version.skill_name,
+ parsed.body,
+ version.files,
+ [str(e.get("ref", "")) for e in version.evidence],
+ )
+
+
+def _deleted_behavior(
+ skill_name: str,
+ body: str,
+ files: list[SkillVersionFile] | None,
+ evidence_refs: list[str] | None = None,
+) -> DeletedBehavior:
+ return DeletedBehavior(
+ behavior_fingerprint=behavior_fingerprint(skill_name, body, files),
+ behavior_tokens=behavior_tokens(body),
+ evidence_fingerprints=(
+ [evidence_fingerprint(evidence_refs)] if evidence_refs else []
+ ),
+ )
class SkillContentBlockedError(ValueError):
@@ -1008,27 +1159,9 @@ async def store_user_skills(
return cast(list[StoredSkill | Exception], outcomes)
# Coordinate ordinary package writes; the database owns the hard cap.
- lock: AsyncClusterLock | None = None
- lock_held = False
- try:
- lock = AsyncClusterLock(
- redis=await get_redis_async(),
- key=f"{_SKILL_WRITE_LOCK_KEY_PREFIX}{user_id}:{expert_id or 'autopilot'}",
- owner_id=uuid.uuid4().hex,
- timeout=_SKILL_WRITE_LOCK_TTL_SECONDS,
- )
- for _ in range(10):
- if (await lock.try_acquire()) == lock.owner_id:
- lock_held = True
- break
- await asyncio.sleep(0.1)
- except Exception:
- logger.warning(
- "[skills] failed to acquire write lock for user %s — "
- "falling back to unlocked best-effort write",
- user_id,
- exc_info=True,
- )
+ # Without the lock they fall back to a best-effort unlocked write.
+ lock = await _acquire_skill_write_lock(user_id, expert_id)
+ lock_held = lock is not None
try:
manager = await _get_user_skill_manager(user_id, scope)
existing = await _list_user_skills_from_workspace(user_id, expert_id, scope)
@@ -1097,14 +1230,43 @@ async def store_user_skills(
return cast(list[StoredSkill | Exception], outcomes)
finally:
if lock is not None and lock_held:
- try:
- await lock.release()
- except Exception:
- logger.warning(
- "[skills] failed to release write lock for user %s",
- user_id,
- exc_info=True,
- )
+ await _release_skill_write_lock(lock, user_id)
+
+
+async def _acquire_skill_write_lock(
+ user_id: str, expert_id: str | None
+) -> AsyncClusterLock | None:
+ """Take the owner's skill write lock, or ``None`` when it stays held
+ elsewhere for about a second or Redis cannot be reached."""
+ try:
+ lock = AsyncClusterLock(
+ redis=await get_redis_async(),
+ key=f"{_SKILL_WRITE_LOCK_KEY_PREFIX}{user_id}:{expert_id or 'autopilot'}",
+ owner_id=uuid.uuid4().hex,
+ timeout=_SKILL_WRITE_LOCK_TTL_SECONDS,
+ )
+ for _ in range(10):
+ if (await lock.try_acquire()) == lock.owner_id:
+ return lock
+ await asyncio.sleep(0.1)
+ except Exception:
+ logger.warning(
+ "[skills] failed to acquire write lock for user %s",
+ user_id,
+ exc_info=True,
+ )
+ return None
+
+
+async def _release_skill_write_lock(lock: AsyncClusterLock, user_id: str) -> None:
+ try:
+ await lock.release()
+ except Exception:
+ logger.warning(
+ "[skills] failed to release write lock for user %s",
+ user_id,
+ exc_info=True,
+ )
async def _require_current_head(
@@ -3420,7 +3582,7 @@ class DeleteSkillTool(BaseTool):
return ErrorResponse(message=str(exc), session_id=session_id)
except SkillNotFoundError as exc:
return ErrorResponse(message=str(exc), session_id=session_id)
- except ConflictError as exc:
+ except (ConflictError, SkillWriteLockError, SkillVersionConflictError) as exc:
return ErrorResponse(message=str(exc), session_id=session_id)
except Exception as exc:
logger.exception("[skills] delete failed for %s", name)
diff --git a/autogpt_platform/backend/backend/copilot/tools/skills_test.py b/autogpt_platform/backend/backend/copilot/tools/skills_test.py
index e6280da3ba..2ec2dcee90 100644
--- a/autogpt_platform/backend/backend/copilot/tools/skills_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/skills_test.py
@@ -12,6 +12,7 @@ import pytest
import backend.copilot.tools.skills as skills
from backend.copilot.baseline.service import _prepend_skills_notice_to_current_message
+from backend.copilot.learning.fingerprint import behavior_fingerprint
from backend.copilot.model import ChatMessage, ChatSession
from backend.copilot.sdk.service import _maybe_prepend_skills_update
from backend.copilot.tools.models import ErrorResponse
@@ -44,7 +45,9 @@ from backend.copilot.tools.skills import (
SkillOwnedError,
SkillPackage,
SkillPackageError,
+ SkillVersionConflictError,
SkillWrite,
+ SkillWriteLockError,
StoredSkill,
StoreSkillResponse,
StoreSkillTool,
@@ -71,6 +74,8 @@ from backend.copilot.tools.skills import (
store_user_skills,
validate_package,
)
+from backend.data.skill_deletion import SkillDeletion
+from backend.data.skill_publication import VersionDraft
from backend.util.exceptions import ConflictError
# ---------------------------------------------------------------------------
@@ -1127,6 +1132,21 @@ async def test_delete_skill_returns_error_when_missing():
assert "not found" in result.message.lower()
+async def test_delete_skill_reports_a_held_write_lock_and_deletes_nothing():
+ tool = DeleteSkillTool()
+ fake_manager = _FakeWorkspaceManager()
+ fake_manager.files["/skills/my_skill/SKILL.md"] = b"skill"
+ with _patch_skills_path(fake_manager) as patched:
+ patched.lock.try_acquire.return_value = "another-writer"
+ result = await tool._execute(
+ user_id="user-1", session=_make_session(), name="my_skill"
+ )
+ assert isinstance(result, ErrorResponse)
+ assert "try again" in result.message
+ assert "/skills/my_skill/SKILL.md" in fake_manager.files
+
+
# ---------------------------------------------------------------------------
# ListSkillsTool + list_all_skills + build_skills_context
# ---------------------------------------------------------------------------
@@ -1651,6 +1671,142 @@ async def test_delete_user_skill_raises_not_found_when_missing():
await delete_user_skill("user-1", "missing")
+async def _tracked_skill(store, body: str) -> str:
+ """Publish *body* as the current ready version of ``tracked``; returns
+ the SKILL.md it renders to."""
+ content = render_skill_markdown(
+ ParsedSkill(name="tracked", description="Tracked", body=body)
+ )
+ head = await store.ensure_head("user-1", None, "tracked")
+ result = await store.commit_version_safe(
+ "user-1",
+ head=head,
+ expected_current_version=head.current_version,
+ draft=VersionDraft(
+ content=content,
+ description="Tracked",
+ triggers=[],
+ origin="saved_overnight",
+ base_version_id=head.current_version_id,
+ ),
+ )
+ await store.complete_publication(
+ "user-1", version_id=result.version.id, review_id=None
+ )
+ return content
+
+
+async def test_delete_user_skill_ends_the_history_under_the_write_lock(
+ fake_learning_store,
+):
+ body = "## Steps\n1. Open the file as utf-8\n"
+ fake_manager = _FakeWorkspaceManager()
+ fake_manager.files["/skills/tracked/SKILL.md"] = (
+ await _tracked_skill(fake_learning_store, body)
+ ).encode()
+ with _patch_skills_path(fake_manager) as patched:
+ await delete_user_skill("user-1", "tracked")
+ patched.lock.release.assert_awaited_once()
+ head = await fake_learning_store.get_head("user-1", "personal", "tracked")
+ assert head.current_version_id is None
+ versions = await fake_learning_store.list_versions("user-1", "personal", "tracked")
+ assert [(v.version, v.state) for v in versions] == [(2, "deleted"), (1, "archived")]
+ [suppressed] = await fake_learning_store.list_suppressions(
+ "user-1", "personal", "tracked"
+ )
+ assert suppressed.behavior_fingerprint == behavior_fingerprint("tracked", body)
+
+
+async def test_delete_user_skill_deletes_nothing_without_the_write_lock(
+ fake_learning_store,
+):
+ fake_manager = _FakeWorkspaceManager()
+ fake_manager.files["/skills/tracked/SKILL.md"] = (
+ await _tracked_skill(fake_learning_store, "## Steps\n1. Keep me\n")
+ ).encode()
+ with _patch_skills_path(fake_manager) as patched:
+ patched.lock.try_acquire.return_value = "another-writer"
+ with pytest.raises(SkillWriteLockError):
+ await delete_user_skill("user-1", "tracked")
+ assert "/skills/tracked/SKILL.md" in fake_manager.files
+ head = await fake_learning_store.get_head("user-1", "personal", "tracked")
+ assert head.current_version_id is not None
+
+
+async def test_delete_user_skill_stops_cleaning_up_once_the_lock_is_lost(
+ fake_learning_store,
+):
+ """After the lease is lost, another writer may own the folder: the
+ delete leaves the remaining files rather than risk deleting theirs."""
+ fake_manager = _FakeWorkspaceManager()
+ fake_manager.files["/skills/tracked/SKILL.md"] = (
+ await _tracked_skill(fake_learning_store, "## Steps\n1. Open the file\n")
+ ).encode()
+ fake_manager.files["/skills/tracked/scripts/run.py"] = b"print(1)"
+ with _patch_skills_path(fake_manager) as patched:
+ patched.lock.refresh.return_value = False
+ await delete_user_skill("user-1", "tracked")
+ assert "/skills/tracked/SKILL.md" not in fake_manager.files
+ assert "/skills/tracked/scripts/run.py" in fake_manager.files
+ head = await fake_learning_store.get_head("user-1", "personal", "tracked")
+ assert head.current_version_id is None
+
+
+async def test_delete_user_skill_rereads_a_head_a_publication_moved(
+ fake_learning_store, monkeypatch
+):
+ """A publication's pointer swap takes no write lock, so it can land
+ between the delete's read and its transaction: the delete reads again
+ and suppresses the newer version too."""
+ store = fake_learning_store
+ fake_manager = _FakeWorkspaceManager()
+ fake_manager.files["/skills/tracked/SKILL.md"] = (
+ await _tracked_skill(store, "## Steps\n1. Open the file\n")
+ ).encode()
+ newer = "## Steps\n1. Open the file\n2. Count the rows\n"
+ record = store.record_skill_deletion
+
+ async def publish_first(*args, **kwargs):
+ monkeypatch.setattr(store, "record_skill_deletion", record)
+ await _tracked_skill(store, newer)
+ return await record(*args, **kwargs)
+
+ monkeypatch.setattr(store, "record_skill_deletion", publish_first)
+ with _patch_skills_path(fake_manager):
+ await delete_user_skill("user-1", "tracked")
+ head = await store.get_head("user-1", "personal", "tracked")
+ assert head.current_version_id is None
+ fingerprints = {
+ s.behavior_fingerprint
+ for s in await store.list_suppressions("user-1", "personal", "tracked")
+ }
+ assert behavior_fingerprint("tracked", newer) in fingerprints
+
+
+async def test_delete_user_skill_gives_up_on_a_head_that_keeps_moving(
+ fake_learning_store, monkeypatch
+):
+ moved = AsyncMock(return_value=SkillDeletion(committed=False))
+ monkeypatch.setattr(fake_learning_store, "record_skill_deletion", moved)
+ fake_manager = _FakeWorkspaceManager()
+ fake_manager.files["/skills/tracked/SKILL.md"] = (
+ await _tracked_skill(fake_learning_store, "## Steps\n1. Keep me\n")
+ ).encode()
+ with (
+ _patch_skills_path(fake_manager) as patched,
+ pytest.raises(SkillVersionConflictError),
+ ):
+ await delete_user_skill("user-1", "tracked")
+ assert moved.await_count == 3
+ patched.lock.release.assert_awaited_once()
+ assert "/skills/tracked/SKILL.md" in fake_manager.files
+
+
@pytest.mark.asyncio
async def test_list_user_skills_uses_metadata_fast_path(mocker):
"""When ``WorkspaceFile.metadata`` carries the kind+description tag,
@@ -1671,12 +1827,15 @@ async def test_list_user_skills_uses_metadata_fast_path(mocker):
with _patch_skills_path(fake_manager):
# Disable cache for this test so we exercise the workspace path.
- with patch(
- "backend.copilot.tools.skills._read_skills_cache",
- new=AsyncMock(return_value=None),
- ), patch(
- "backend.copilot.tools.skills._write_skills_cache",
- new=AsyncMock(),
+ with (
+ patch(
+ "backend.copilot.tools.skills._read_skills_cache",
+ new=AsyncMock(return_value=None),
+ ),
+ patch(
+ "backend.copilot.tools.skills._write_skills_cache",
+ new=AsyncMock(),
+ ),
):
skills = await list_user_skills("user-1")
@@ -1700,12 +1859,15 @@ async def test_list_user_skills_falls_back_to_read_without_metadata(mocker):
# metadata dict left empty → triggers the fallback path.
with _patch_skills_path(fake_manager):
- with patch(
- "backend.copilot.tools.skills._read_skills_cache",
- new=AsyncMock(return_value=None),
- ), patch(
- "backend.copilot.tools.skills._write_skills_cache",
- new=AsyncMock(),
+ with (
+ patch(
+ "backend.copilot.tools.skills._read_skills_cache",
+ new=AsyncMock(return_value=None),
+ ),
+ patch(
+ "backend.copilot.tools.skills._write_skills_cache",
+ new=AsyncMock(),
+ ),
):
skills = await list_user_skills("user-1")
@@ -1730,12 +1892,15 @@ async def test_list_user_skills_returns_redis_cache_when_warm():
fake_redis = MagicMock()
fake_redis.get = AsyncMock(return_value=json.dumps(cached_payload))
fake_redis.set = AsyncMock()
- with patch(
- "backend.copilot.tools.skills.get_redis_async",
- new=AsyncMock(return_value=fake_redis),
- ), patch(
- "backend.copilot.tools.skills._get_user_skill_manager",
- new=AsyncMock(side_effect=AssertionError("cache hit must skip workspace")),
+ with (
+ patch(
+ "backend.copilot.tools.skills.get_redis_async",
+ new=AsyncMock(return_value=fake_redis),
+ ),
+ patch(
+ "backend.copilot.tools.skills._get_user_skill_manager",
+ new=AsyncMock(side_effect=AssertionError("cache hit must skip workspace")),
+ ),
):
skills = await list_user_skills("user-1")
@@ -1786,15 +1951,20 @@ async def test_build_skills_context_normal_when_flag_enabled():
fake_manager.files["/skills/x/SKILL.md"] = render_skill_markdown(
ParsedSkill(name="x", description="ok", body="b")
).encode()
- with _patch_skills_path(fake_manager), patch(
- "backend.copilot.tools.skills.is_skills_feature_enabled",
- new=AsyncMock(return_value=True),
- ), patch(
- "backend.copilot.tools.skills._read_skills_cache",
- new=AsyncMock(return_value=None),
- ), patch(
- "backend.copilot.tools.skills._write_skills_cache",
- new=AsyncMock(),
+ with (
+ _patch_skills_path(fake_manager),
+ patch(
+ "backend.copilot.tools.skills.is_skills_feature_enabled",
+ new=AsyncMock(return_value=True),
+ ),
+ patch(
+ "backend.copilot.tools.skills._read_skills_cache",
+ new=AsyncMock(return_value=None),
+ ),
+ patch(
+ "backend.copilot.tools.skills._write_skills_cache",
+ new=AsyncMock(),
+ ),
):
result = await build_skills_context("user-1")
diff --git a/autogpt_platform/backend/backend/data/db_accessors.py b/autogpt_platform/backend/backend/data/db_accessors.py
index b710be297c..60e504bf8b 100644
--- a/autogpt_platform/backend/backend/data/db_accessors.py
+++ b/autogpt_platform/backend/backend/data/db_accessors.py
@@ -348,6 +348,19 @@ def skill_use_db():
return skill_use_db
+def skill_deletion_db():
+ if db.is_connected():
+ from backend.data import skill_deletion as _skill_deletion_db
+
+ skill_deletion_db = _skill_deletion_db
+ else:
+ from backend.util.clients import get_database_manager_async_client
+
+ skill_deletion_db = get_database_manager_async_client()
+
+ return skill_deletion_db
+
+
def skill_versions_db():
if db.is_connected():
from backend.data import skill_versions as _skill_versions_db
diff --git a/autogpt_platform/backend/backend/data/db_manager.py b/autogpt_platform/backend/backend/data/db_manager.py
index f713ed3d90..0f2d81c560 100644
--- a/autogpt_platform/backend/backend/data/db_manager.py
+++ b/autogpt_platform/backend/backend/data/db_manager.py
@@ -63,6 +63,7 @@ from backend.copilot.sharing.db import link_new_execution_to_chat_share
from backend.data import bot_analytics as bot_analytics_db
from backend.data import bot_installs as bot_installs_db
from backend.data import db
+from backend.data import skill_deletion as skill_deletion_data
from backend.data import skill_learning as skill_learning_data
from backend.data import skill_publication as skill_publication_data
from backend.data import skill_reviews as skill_reviews_data
@@ -655,6 +656,7 @@ class DatabaseManager(AppService):
list_heads = _(skill_versions_data.list_heads)
list_use_paused_skill_names = _(skill_versions_data.list_use_paused_skill_names)
update_head_policy = _(skill_versions_data.update_head_policy)
+ pause_use_if_current = _(skill_versions_data.pause_use_if_current)
publish_version_if_current = _(skill_versions_data.publish_version_if_current)
commit_version_safe = _(skill_publication_data.commit_version_safe)
complete_publication = _(skill_publication_data.complete_publication)
@@ -672,6 +674,7 @@ class DatabaseManager(AppService):
list_versions_in_states = _(skill_versions_data.list_versions_in_states)
invalidate_source_versions = _(skill_versions_data.invalidate_source_versions)
latest_independent_version_id = _(skill_versions_data.latest_independent_version_id)
+ record_skill_deletion = _(skill_deletion_data.record_skill_deletion)
add_suppression = _(skill_use_data.add_suppression)
find_suppression = _(skill_use_data.find_suppression)
list_suppressions = _(skill_use_data.list_suppressions)
@@ -1148,6 +1151,7 @@ class DatabaseManagerAsyncClient(AppServiceClient):
list_heads = d.list_heads
list_use_paused_skill_names = d.list_use_paused_skill_names
update_head_policy = d.update_head_policy
+ pause_use_if_current = d.pause_use_if_current
publish_version_if_current = d.publish_version_if_current
commit_version_safe = d.commit_version_safe
complete_publication = d.complete_publication
@@ -1163,6 +1167,7 @@ class DatabaseManagerAsyncClient(AppServiceClient):
list_versions_in_states = d.list_versions_in_states
invalidate_source_versions = d.invalidate_source_versions
latest_independent_version_id = d.latest_independent_version_id
+ record_skill_deletion = d.record_skill_deletion
add_suppression = d.add_suppression
find_suppression = d.find_suppression
list_suppressions = d.list_suppressions
diff --git a/autogpt_platform/backend/backend/data/skill_deletion.py b/autogpt_platform/backend/backend/data/skill_deletion.py
new file mode 100644
index 0000000000..e3918aca9f
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/skill_deletion.py
@@ -0,0 +1,257 @@
+"""Record an owner's deletion of a skill in its version history.
+
+Deleting a skill removes its workspace package, but the head would still
+name the last version and the older versions would stay ``ready``:
+excluding an old source would then restore one of them, and a learned
+``create`` for the name would conflict with the head for good.
+:func:`record_skill_deletion` ends the history in one transaction instead.
+It suppresses the deleted behaviour, appends a ``deleted`` marker version,
+clears the head's pointer and per-skill policy, settles any publication
+still waiting for its workspace write, and archives what is left.
+"""
+
+from __future__ import annotations
+
+import prisma.errors
+import prisma.models
+from prisma import Prisma
+from pydantic import BaseModel, Field
+
+from backend.data.db import query_raw_with_schema, transaction
+from backend.data.skill_content_approvals import content_approvals_json
+from backend.data.skill_learning import owner_key_for
+from backend.data.skill_publication_settlement import settle_publication_in
+from backend.data.skill_version_files import version_files_json
+from backend.data.skill_versions import (
+ PENDING_WRITE_STATE,
+ SkillVersionRecord,
+ content_hash,
+ next_version_number,
+)
+from backend.util.json import SafeJson
+
+DELETED_STATE = "deleted"
+DELETED_ORIGIN = "deleted"
+DELETED_REASON = "the skill was deleted"
+
+
+class DeletedBehavior(BaseModel):
+ """One deleted behaviour, as its suppression record will hold it."""
+
+ behavior_fingerprint: str
+ behavior_tokens: list[str] = Field(default_factory=list)
+ evidence_fingerprints: list[str] = Field(default_factory=list)
+
+
+class SkillDeletion(BaseModel):
+ """``committed=False`` means the head moved after the caller read it, so
+ nothing was recorded; read it again and retry."""
+
+ committed: bool
+ marker: SkillVersionRecord | None = None
+ archived_version_ids: list[str] = Field(default_factory=list)
+ abandoned_version_ids: list[str] = Field(default_factory=list)
+
+
+class _HeadChanged(Exception):
+ """Internal: rolls the deletion back when the head moved."""
+
+
+async def record_skill_deletion(
+ user_id: str,
+ *,
+ expert_id: str | None,
+ skill_name: str,
+ expected_current_version_id: str | None,
+ behaviors: list[DeletedBehavior],
+ actor_user_id: str | None,
+) -> SkillDeletion:
+ """End *skill_name*'s history and suppress *behaviors*, or change nothing.
+
+ Locks are taken in the order a publication takes them, the new version
+ row and then the head, so the two never deadlock. Whichever moves the
+ head first wins. The loser finds the head changed, or its version number
+ taken, and rolls back: a publication reports a conflict, and a deletion
+ returns ``committed=False``. A skill with no head gets one, so every
+ deletion leaves a marker. The next version under the name starts a new
+ chain: the head names no version, and the marker links to none, so
+ revoking a source of the deleted history can never reach it.
+ """
+ try:
+ async with transaction() as tx:
+ return await _record(
+ tx,
+ user_id,
+ expert_id=expert_id,
+ skill_name=skill_name,
+ expected_current_version_id=expected_current_version_id,
+ behaviors=behaviors,
+ actor_user_id=actor_user_id,
+ )
+ except (_HeadChanged, prisma.errors.UniqueViolationError):
+ return SkillDeletion(committed=False)
+
+
+async def _record(
+ tx: Prisma,
+ user_id: str,
+ *,
+ expert_id: str | None,
+ skill_name: str,
+ expected_current_version_id: str | None,
+ behaviors: list[DeletedBehavior],
+ actor_user_id: str | None,
+) -> SkillDeletion:
+ owner_key = owner_key_for(expert_id)
+ head = await tx.skillhead.find_unique(
+ where={
+ "userId_ownerKey_skillName": {
+ "userId": user_id,
+ "ownerKey": owner_key,
+ "skillName": skill_name,
+ }
+ }
+ )
+ current_id = head.currentVersionId if head is not None else None
+ if current_id != expected_current_version_id:
+ raise _HeadChanged()
+ if behaviors:
+ await _suppress(tx, user_id, expert_id, skill_name, behaviors, actor_user_id)
+ if head is None:
+ # A skill saved before version history has no head. It gets one, so
+ # the deletion is on record and a learning run that read the package
+ # earlier cannot import it as an existing skill afterwards.
+ head = await tx.skillhead.create(
+ data={
+ "userId": user_id,
+ "expertId": expert_id,
+ "ownerKey": owner_key,
+ "skillName": skill_name,
+ }
+ )
+ marker = await _append_marker(tx, head, actor_user_id)
+ ended = await tx.skillhead.update_many(
+ where={
+ "id": head.id,
+ "currentVersion": head.currentVersion,
+ "currentVersionId": current_id,
+ },
+ data={
+ "currentVersion": marker.version,
+ "currentVersionId": None,
+ "contentHash": None,
+ "autoImprove": True,
+ "learningPausedAt": None,
+ "usePausedAt": None,
+ },
+ )
+ if not ended:
+ raise _HeadChanged()
+ abandoned = await _settle_pending(tx, user_id, head.id)
+ # A ``ready`` version is what a source revocation would restore, and an
+ # open proposal would edit a skill that is gone. Archived after the
+ # pending ones are settled: ``complete_publication`` runs outside the
+ # write lock, and a version it turns ready in between is caught here.
+ archived = await query_raw_with_schema(
+ """UPDATE {schema_prefix}"SkillVersion"
+ SET "state" = 'archived', "stateReason" = $3
+ WHERE "userId" = $1 AND "headId" = $2
+ AND "state" IN ('ready', 'needs_decision')
+ RETURNING "id" """,
+ user_id,
+ head.id,
+ DELETED_REASON,
+ client=tx,
+ )
+ return SkillDeletion(
+ committed=True,
+ marker=SkillVersionRecord.from_db(marker),
+ archived_version_ids=[str(row["id"]) for row in archived],
+ abandoned_version_ids=abandoned,
+ )
+
+
+async def _suppress(
+ tx: Prisma,
+ user_id: str,
+ expert_id: str | None,
+ skill_name: str,
+ behaviors: list[DeletedBehavior],
+ actor_user_id: str | None,
+) -> None:
+ await tx.skillsuppression.create_many(
+ data=[
+ {
+ "userId": user_id,
+ "expertId": expert_id,
+ "ownerKey": owner_key_for(expert_id),
+ "skillName": skill_name,
+ "behaviorFingerprint": behavior.behavior_fingerprint,
+ "behaviorTokens": list(behavior.behavior_tokens),
+ "evidenceFingerprints": list(behavior.evidence_fingerprints),
+ "actorUserId": actor_user_id,
+ "reason": "deleted by the owner",
+ }
+ for behavior in behaviors
+ ],
+ skip_duplicates=True,
+ )
+
+
+async def _append_marker(
+ tx: Prisma, head: prisma.models.SkillHead, actor_user_id: str | None
+) -> prisma.models.SkillVersion:
+ # A version number a concurrent publication already holds fails the
+ # insert, which rolls the deletion back for the caller to retry.
+ return await tx.skillversion.create(
+ data={
+ "userId": head.userId,
+ "expertId": head.expertId,
+ "ownerKey": head.ownerKey,
+ "skillName": head.skillName,
+ "headId": head.id,
+ "version": await next_version_number(head.id),
+ "content": "",
+ "contentHash": content_hash(""),
+ "packageFiles": version_files_json(None),
+ "contentApprovals": content_approvals_json([]),
+ "description": "",
+ "triggers": [],
+ "origin": DELETED_ORIGIN,
+ "actorUserId": actor_user_id,
+ "summary": (
+ f"Deleted v{head.currentVersion}"
+ if head.currentVersionId
+ else "Deleted"
+ ),
+ "sources": SafeJson([]),
+ "evidence": SafeJson([]),
+ "limits": [],
+ "state": DELETED_STATE,
+ }
+ )
+
+
+async def _settle_pending(tx: Prisma, user_id: str, head_id: str) -> list[str]:
+ """Settle publications still waiting for their workspace write.
+
+ ``suppressed`` is terminal, so the review is not re-run for a skill its
+ owner deleted. A version that turned ready meanwhile is not pending any
+ more and is left to the archive step.
+ """
+ pending = await tx.skillversion.find_many(
+ where={"userId": user_id, "headId": head_id, "state": PENDING_WRITE_STATE}
+ )
+ return [
+ version.id
+ for version in pending
+ if await settle_publication_in(
+ tx,
+ user_id,
+ version_id=version.id,
+ review_id=version.reviewId,
+ state="stale",
+ disposition="suppressed",
+ reason=DELETED_REASON,
+ )
+ ]
diff --git a/autogpt_platform/backend/backend/data/skill_deletion_test.py b/autogpt_platform/backend/backend/data/skill_deletion_test.py
new file mode 100644
index 0000000000..cef8ab1d07
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/skill_deletion_test.py
@@ -0,0 +1,353 @@
+"""Recording an owner's deletion against real Postgres (#15540)."""
+
+import asyncio
+from uuid import uuid4
+
+import pytest
+
+from backend.data import skill_deletion as deletion
+from backend.data import skill_publication as publication
+from backend.data import skill_reviews as reviews
+from backend.data import skill_use as use
+from backend.data import skill_versions as versions
+from backend.data.skill_learning_test import _cleanup, _create_user, _source
+from backend.data.skill_publication import ReviewStamp, VersionDraft
+
+OWNER = "personal"
+BEHAVIOR = deletion.DeletedBehavior(
+ behavior_fingerprint="deleted-procedure", behavior_tokens=["learned", "procedure"]
+)
+
+
+async def _publish(user: str, name: str, content: str, **draft):
+ head = await versions.ensure_head(user, None, name)
+ result = await publication.commit_version_safe(
+ user,
+ head=head,
+ draft=VersionDraft(
+ content=content,
+ description="Test",
+ origin="saved_overnight",
+ base_version_id=head.current_version_id,
+ **draft,
+ ),
+ expected_current_version=head.current_version,
+ )
+ await publication.complete_publication(
+ user, version_id=result.version.id, review_id=None
+ )
+ return result.version
+
+
+async def _delete(user: str, name: str, expected: str | None):
+ return await deletion.record_skill_deletion(
+ user,
+ expert_id=None,
+ skill_name=name,
+ expected_current_version_id=expected,
+ behaviors=[BEHAVIOR, BEHAVIOR],
+ actor_user_id=user,
+ )
+
+
[email protected](loop_scope="session")
+async def test_deletion_ends_the_history_and_the_next_write_starts_a_new_chain(
+ server,
+):
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ source = await _source(user)
+ independent = await _publish(user, "deleted-check", "Independent procedure")
+ learned = await _publish(
+ user,
+ "deleted-check",
+ "Learned procedure",
+ sources=[{"source_id": source.id}],
+ )
+ before = await versions.get_head(user, OWNER, "deleted-check")
+ proposal = await versions.create_version(
+ user,
+ head=before,
+ content="Proposed procedure",
+ description="Test",
+ triggers=[],
+ origin="saved_overnight",
+ state="needs_decision",
+ base_version_id=learned.id,
+ )
+ await versions.update_head_policy(
+ user,
+ OWNER,
+ "deleted-check",
+ auto_improve=False,
+ learning_paused=True,
+ use_paused=True,
+ )
+
+ result = await _delete(user, "deleted-check", learned.id)
+
+ assert result.committed
+ assert set(result.archived_version_ids) == {
+ independent.id,
+ learned.id,
+ proposal.id,
+ }
+ marker = result.marker
+ assert (marker.state, marker.origin, marker.content, marker.summary) == (
+ "deleted",
+ "deleted",
+ "",
+ f"Deleted v{learned.version}",
+ )
+ head = await versions.get_head(user, OWNER, "deleted-check")
+ assert head.current_version_id is None
+ assert head.current_version == marker.version
+ assert head.content_hash is None
+ assert head.auto_improve
+ assert head.learning_paused_at is None and head.use_paused_at is None
+ assert await versions.latest_independent_version_id(user, head.id) is None
+ [suppressed] = await use.list_suppressions(user, OWNER, "deleted-check")
+ assert suppressed.behavior_fingerprint == "deleted-procedure"
+ assert suppressed.behavior_tokens == ["learned", "procedure"]
+
+ revoked = await versions.invalidate_source_versions(
+ user, source.id, "source excluded"
+ )
+ assert {v.id for v in revoked} == {learned.id, proposal.id}
+ assert (
+ await versions.get_head(user, OWNER, "deleted-check")
+ ).current_version_id is None
+
+ stale = await publication.commit_version_safe(
+ user,
+ head=before,
+ draft=VersionDraft(
+ content="Read before the delete",
+ description="Test",
+ origin="saved_overnight",
+ base_version_id=learned.id,
+ ),
+ expected_current_version=before.current_version,
+ )
+ assert not stale.committed
+ fresh = await _publish(user, "deleted-check", "A different procedure")
+ assert fresh.version == marker.version + 1
+ assert fresh.base_version_id is None
+ finally:
+ await _cleanup(user)
+
+
[email protected](loop_scope="session")
+async def test_deletion_settles_a_publication_waiting_for_its_write(server):
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ source = await _source(user)
+ head = await versions.ensure_head(user, None, "pending-check")
+ pending = await publication.commit_version(
+ user,
+ head=head,
+ draft=VersionDraft(
+ content="Pending procedure",
+ description="Test",
+ origin="saved_overnight",
+ sources=[{"source_id": source.id}],
+ ),
+ expected_current_version=head.current_version,
+ review=ReviewStamp(
+ source=source,
+ source_revision=source.revision,
+ policy_version=1,
+ run_id="run-1",
+ ),
+ )
+ assert pending.committed and pending.review_id is not None
+
+ result = await _delete(user, "pending-check", pending.version.id)
+
+ assert result.abandoned_version_ids == [pending.version.id]
+ assert (await versions.get_version(user, pending.version.id)).state == "stale"
+ review = await reviews.get_review(user, pending.review_id)
+ assert review.disposition == "suppressed"
+ assert review.completed_at is not None
+ assert await publication.list_pending_publications(user) == []
+ finally:
+ await _cleanup(user)
+
+
[email protected](loop_scope="session")
+async def test_a_publication_landing_mid_deletion_wins_without_a_deadlock(
+ server, monkeypatch
+):
+ """A publication commits the version number the deletion just read. The
+ deletion must not hold the head while the publication's insert checks it
+ (a lock-order deadlock): the publication completes, and the deletion
+ rolls back for its caller to read the head again."""
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ current = await _publish(user, "race-check", "Current procedure")
+ head = await versions.get_head(user, OWNER, "race-check")
+ allocate = deletion.next_version_number
+ raced = {}
+
+ async def publish_meanwhile(head_id: str) -> int:
+ number = await allocate(head_id)
+ raced["result"] = await asyncio.wait_for(
+ publication.commit_version_safe(
+ user,
+ head=head,
+ draft=VersionDraft(
+ content="Published meanwhile",
+ description="Test",
+ origin="saved_overnight",
+ base_version_id=current.id,
+ ),
+ expected_current_version=head.current_version,
+ ),
+ timeout=10,
+ )
+ return number
+
+ monkeypatch.setattr(deletion, "next_version_number", publish_meanwhile)
+
+ result = await _delete(user, "race-check", current.id)
+
+ assert raced["result"].committed
+ assert not result.committed
+ after = await versions.get_head(user, OWNER, "race-check")
+ assert after.current_version_id == raced["result"].version.id
+ assert await use.list_suppressions(user, OWNER, "race-check") == []
+ finally:
+ await _cleanup(user)
+
+
[email protected](loop_scope="session")
+async def test_a_publication_completing_mid_deletion_is_still_archived(
+ server, monkeypatch
+):
+ """``complete_publication`` takes no write lock, so a pending version can
+ turn ready while the deletion runs. It must still end up archived, not
+ left ready for a revocation to restore."""
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ head = await versions.ensure_head(user, None, "completing-check")
+ pending = await publication.commit_version_safe(
+ user,
+ head=head,
+ draft=VersionDraft(
+ content="Pending procedure", description="Test", origin="edited"
+ ),
+ expected_current_version=head.current_version,
+ )
+ settle = deletion.settle_publication_in
+
+ async def complete_meanwhile(tx, user_id, **kwargs):
+ await publication.complete_publication(
+ user_id, version_id=kwargs["version_id"], review_id=None
+ )
+ return await settle(tx, user_id, **kwargs)
+
+ monkeypatch.setattr(deletion, "settle_publication_in", complete_meanwhile)
+
+ result = await _delete(user, "completing-check", pending.version.id)
+
+ assert result.committed
+ assert result.abandoned_version_ids == []
+ assert result.archived_version_ids == [pending.version.id]
+ version = await versions.get_version(user, pending.version.id)
+ assert version.state == "archived"
+ finally:
+ await _cleanup(user)
+
+
[email protected](loop_scope="session")
+async def test_a_use_pause_lands_only_while_the_head_names_the_version(server):
+ """Revocation's pause for a version with no fallback is a compare-and-swap:
+ once a deletion has ended the head, the pause changes nothing."""
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ current = await _publish(user, "pause-check", "Current procedure")
+ head = await versions.get_head(user, OWNER, "pause-check")
+ assert await versions.pause_use_if_current(user, head.id, current.id)
+ assert (await versions.get_head(user, OWNER, "pause-check")).use_paused_at
+
+ await versions.update_head_policy(user, OWNER, "pause-check", use_paused=False)
+ assert (await _delete(user, "pause-check", current.id)).committed
+ assert not await versions.pause_use_if_current(user, head.id, current.id)
+ after = await versions.get_head(user, OWNER, "pause-check")
+ assert after.deleted and after.use_paused_at is None
+ finally:
+ await _cleanup(user)
+
+
[email protected](loop_scope="session")
+async def test_deletion_against_a_moved_head_records_nothing(server):
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ current = await _publish(user, "moved-check", "Current procedure")
+
+ result = await _delete(user, "moved-check", "a-version-read-earlier")
+
+ assert not result.committed
+ assert await use.list_suppressions(user, OWNER, "moved-check") == []
+ head = await versions.get_head(user, OWNER, "moved-check")
+ assert head.current_version_id == current.id
+ assert [
+ v.id for v in await versions.list_versions(user, OWNER, "moved-check")
+ ] == [current.id]
+ finally:
+ await _cleanup(user)
+
+
[email protected](loop_scope="session")
+async def test_deleting_a_skill_whose_head_never_named_a_version(server):
+ """A head can exist without a current version, e.g. after a blocked
+ learning attempt; deleting the skill still ends its history."""
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ head = await versions.ensure_head(user, None, "unpublished-check")
+ blocked = await versions.create_version(
+ user,
+ head=head,
+ content="",
+ description="Blocked",
+ triggers=[],
+ origin="saved_overnight",
+ state="blocked_content",
+ )
+
+ result = await _delete(user, "unpublished-check", None)
+
+ assert result.committed
+ assert result.marker.summary == "Deleted"
+ after = await versions.get_head(user, OWNER, "unpublished-check")
+ assert after.current_version == result.marker.version
+ assert after.current_version_id is None
+ assert (await versions.get_version(user, blocked.id)).state == "blocked_content"
+ finally:
+ await _cleanup(user)
+
+
[email protected](loop_scope="session")
+async def test_deleting_a_skill_with_no_history_gives_it_a_deleted_head(server):
+ """A skill saved before version history has no head. Its deletion still
+ leaves one, ended by the marker, so the deletion is on record."""
+ user = str(uuid4())
+ await _create_user(user)
+ try:
+ result = await _delete(user, "never-versioned", None)
+
+ assert result.committed
+ assert (result.marker.version, result.marker.summary) == (1, "Deleted")
+ head = await versions.get_head(user, OWNER, "never-versioned")
+ assert head.deleted
+ assert head.current_version == 1
+ assert len(await use.list_suppressions(user, OWNER, "never-versioned")) == 1
+ finally:
+ await _cleanup(user)
diff --git a/autogpt_platform/backend/backend/data/skill_publication_settlement.py b/autogpt_platform/backend/backend/data/skill_publication_settlement.py
index 1ff15b2f22..8512c7d297 100644
--- a/autogpt_platform/backend/backend/data/skill_publication_settlement.py
+++ b/autogpt_platform/backend/backend/data/skill_publication_settlement.py
@@ -3,6 +3,7 @@
from datetime import datetime, timezone
import prisma.types
+from prisma import Prisma
from backend.data.db import transaction
from backend.data.skill_versions import PENDING_WRITE_STATE
@@ -18,6 +19,30 @@ async def settle_publication(
disposition: str,
reason: str,
) -> None:
+ async with transaction() as tx:
+ await settle_publication_in(
+ tx,
+ user_id,
+ version_id=version_id,
+ review_id=review_id,
+ state=state,
+ disposition=disposition,
+ reason=reason,
+ )
+
+
+async def settle_publication_in(
+ tx: Prisma,
+ user_id: str,
+ *,
+ version_id: str,
+ review_id: str | None,
+ state: str,
+ disposition: str,
+ reason: str,
+) -> bool:
+ """:func:`settle_publication` inside the caller's transaction; False when
+ the version was no longer pending."""
where: prisma.types.SkillVersionWhereInput = {
"id": version_id,
"userId": user_id,
@@ -25,18 +50,18 @@ async def settle_publication(
}
if review_id is not None:
where["reviewId"] = review_id
- async with transaction() as tx:
- changed = await tx.skillversion.update_many(
- where=where, data={"state": state, "stateReason": reason[:1000]}
- )
- if not changed or review_id is None:
- return
- await tx.skilllearningreview.update_many(
- where={"id": review_id, "userId": user_id, "appliedVersionId": version_id},
- data={
- "disposition": disposition,
- "reviewReplay": SafeJson(None),
- "reason": reason[:2000],
- "completedAt": datetime.now(timezone.utc),
- },
- )
+ changed = await tx.skillversion.update_many(
+ where=where, data={"state": state, "stateReason": reason[:1000]}
+ )
+ if not changed or review_id is None:
+ return bool(changed)
+ await tx.skilllearningreview.update_many(
+ where={"id": review_id, "userId": user_id, "appliedVersionId": version_id},
+ data={
+ "disposition": disposition,
+ "reviewReplay": SafeJson(None),
+ "reason": reason[:2000],
+ "completedAt": datetime.now(timezone.utc),
+ },
+ )
+ return True
diff --git a/autogpt_platform/backend/backend/data/skill_versions.py b/autogpt_platform/backend/backend/data/skill_versions.py
index 2b82921ecc..7edf6b9e24 100644
--- a/autogpt_platform/backend/backend/data/skill_versions.py
+++ b/autogpt_platform/backend/backend/data/skill_versions.py
@@ -66,6 +66,15 @@ class SkillHeadRecord(BaseModel):
use_paused_at: datetime | None
updated_at: datetime
+ @property
+ def deleted(self) -> bool:
+ """The owner deleted the skill: the head has moved but names nothing.
+
+ A head that never named a version is at 0; only a deletion clears the
+ pointer of one that has moved.
+ """
+ return self.current_version_id is None and self.current_version > 0
+
@classmethod
def from_db(cls, row: prisma.models.SkillHead) -> "SkillHeadRecord":
return cls(
@@ -235,6 +244,18 @@ async def update_head_policy(
return SkillHeadRecord.from_db(row) if row else head
+async def pause_use_if_current(user_id: str, head_id: str, version_id: str) -> bool:
+ """Stop using the skill only while the head still names *version_id*.
+
+ A deletion or a newer version landing first leaves the head alone.
+ """
+ paused = await prisma.models.SkillHead.prisma().update_many(
+ where={"id": head_id, "userId": user_id, "currentVersionId": version_id},
+ data={"usePausedAt": datetime.now(timezone.utc)},
+ )
+ return paused > 0
+
+
async def publish_version_if_current(
user_id: str,
head_id: str,
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index ca99eaac6a..29d5abf70b 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -15671,7 +15671,7 @@
"delete": {
"tags": ["v1", "skills"],
"summary": "Delete a user-distilled copilot skill",
- "description": "Delete a user-distilled skill by slug.\n\nBuilt-in defaults are not user-deletable — attempting to delete one\nreturns 400. Missing skills return 404 so the UI can reconcile a\nstale list.",
+ "description": "Delete a user-distilled skill by slug.\n\nBuilt-in defaults are not user-deletable — attempting to delete one\nreturns 400. Missing skills return 404 so the UI can reconcile a\nstale list. 409 means the delete could not be ordered with another\nchange to the owner's skills; nothing was deleted, so try again.",
"operationId": "deleteCopilotSkill",
"security": [{ "HTTPBearerJWT": [] }],
"parameters": [
diff --git a/docs/platform/skill-learning.md b/docs/platform/skill-learning.md
index c706d786ce..b2c18ced03 100644
--- a/docs/platform/skill-learning.md
+++ b/docs/platform/skill-learning.md
@@ -87,6 +87,7 @@ still refused.
| Paused (learning) | Future automated changes are off for the skill or Expert |
| Paused (not in use) | The owner stopped using the skill; history is kept |
| Archived | Superseded, stale, or invalidated by a revoked source |
+| Deleted | The owner deleted the skill; its history is kept, archived |
## Controls
@@ -144,6 +145,13 @@ improvements off but does not suppress the behavior: independent valid evidence
can support a new proposal for the owner to decide. A source the viewer can no longer
open shows **Evidence not visible to you** without a title or link.
+Deleting a skill ends its history. Its versions stay in History, archived,
+after a *Deleted* entry, and excluding one of their sources later restores
+nothing. The deleted behaviour is suppressed as an undone change is, so
+learning never reapplies it and a near-identical proposal becomes a decision.
+A genuinely different skill can still be learned under the same name; it
+starts a new history with the default controls.
+
## Adapters
The learner never inspects an application's schema. A source adapter