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): only migrate webhook presets when new trigger is compatible (#13394)

Krzysztof Czerwinskic8a538b87e49
diff --git a/autogpt_platform/backend/backend/api/features/library/db.py b/autogpt_platform/backend/backend/api/features/library/db.py
index caa89a5bcd..9b106d2aba 100644
--- a/autogpt_platform/backend/backend/api/features/library/db.py
+++ b/autogpt_platform/backend/backend/api/features/library/db.py
@@ -817,8 +817,7 @@ async def update_graph_in_library(
if created_graph.webhook_input_node:
await migrate_webhook_presets_to_new_version(
user_id=user_id,
- graph_id=created_graph.id,
- new_version=created_graph.version,
+ new_graph=created_graph,
)
return created_graph, library_agent
@@ -2119,8 +2118,7 @@ async def set_preset_webhook(
async def migrate_webhook_presets_to_new_version(
user_id: str,
- graph_id: str,
- new_version: int,
+ new_graph: graph_db.GraphModel,
) -> int:
"""
Migrates webhook-attached presets for a graph to a newly activated version.
@@ -2130,37 +2128,102 @@ async def migrate_webhook_presets_to_new_version(
to point to the new active version, so that existing webhook URLs
continue to trigger the latest agent version.
- Presets pinned to a newer version than ``new_version`` (e.g. manually
- pinned to a future/specific version) are intentionally left untouched.
+ A preset is only migrated when the new version's trigger is the *same block*
+ as the trigger of the version the preset is currently pinned to. The block
+ id determines the provider, webhook type and resource/event formats the
+ webhook was registered for, so an identical block id guarantees the existing
+ webhook still matches. If the new version swaps or reconfigures the trigger
+ (e.g. v1 used a Telegram trigger, v2 uses a GitHub trigger, or a GitHub "on
+ PR" trigger becomes a GitHub "on issue" trigger), migrating the preset would
+ feed events from the old webhook into an incompatible trigger node, silently
+ breaking the integration. Such presets are left pinned to their current
+ version (where their webhook still works) and flagged for reconfiguration.
+
+ Presets pinned to a newer version than the new one (e.g. manually pinned to
+ a future/specific version) are intentionally left untouched.
Only migrates presets that:
- Belong to the user
- Are attached to a webhook (webhookId is not null)
- Are not deleted
- Are for the given graph and pinned to a strictly older version
+ - Are pinned to a version whose trigger block matches the new version's
Args:
user_id: The owner of the presets.
- graph_id: The graph ID whose presets should be migrated.
- new_version: The newly activated graph version to migrate presets to.
+ new_graph: The newly activated graph version to migrate presets to.
Returns:
The number of presets migrated.
"""
- count = await prisma.models.AgentPreset.prisma().update_many(
+ new_trigger_node = new_graph.webhook_input_node
+ if not (new_trigger_node and new_trigger_node.block.webhook_config):
+ # New version has no webhook trigger to migrate presets onto.
+ return 0
+
+ candidates = await prisma.models.AgentPreset.prisma().find_many(
where={
"userId": user_id,
- "agentGraphId": graph_id,
- "agentGraphVersion": {"lt": new_version},
+ "agentGraphId": new_graph.id,
+ "agentGraphVersion": {"lt": new_graph.version},
"webhookId": {"not": None},
"isDeleted": False,
},
- data={"agentGraphVersion": new_version},
+ )
+ if not candidates:
+ return 0
+
+ # Resolve the trigger block of each pinned version once. A preset is
+ # compatible only if its pinned version uses the same trigger block as the
+ # new version — that's what guarantees the registered webhook still matches.
+ old_trigger_block_by_version: dict[int, str | None] = {}
+ for version in {preset.agentGraphVersion for preset in candidates}:
+ old_graph = await graph_db.get_graph(new_graph.id, version, user_id=user_id)
+ old_trigger_node = old_graph.webhook_input_node if old_graph else None
+ old_trigger_block_by_version[version] = (
+ old_trigger_node.block_id if old_trigger_node else None
+ )
+
+ compatible_ids = {
+ preset.id
+ for preset in candidates
+ if old_trigger_block_by_version.get(preset.agentGraphVersion)
+ == new_trigger_node.block_id
+ }
+
+ for preset in candidates:
+ if preset.id in compatible_ids:
+ continue
+ logger.warning(
+ f"Not migrating preset #{preset.id} for graph #{new_graph.id} to "
+ f"v{new_graph.version}: its trigger block "
+ f"({old_trigger_block_by_version.get(preset.agentGraphVersion)}) "
+ f"differs from the new trigger block ({new_trigger_node.block_id}). "
+ f"Preset left pinned to v{preset.agentGraphVersion}; trigger needs "
+ f"reconfiguration."
+ )
+
+ if not compatible_ids:
+ return 0
+
+ # Preserve candidate order for a deterministic query. Re-assert userId and
+ # the version guard so a concurrent activation that already bumped a preset
+ # past new_graph.version can't be downgraded between the find_many above
+ # and this update.
+ ids_to_migrate = [preset.id for preset in candidates if preset.id in compatible_ids]
+ count = await prisma.models.AgentPreset.prisma().update_many(
+ where={
+ "id": {"in": ids_to_migrate},
+ "userId": user_id,
+ "agentGraphVersion": {"lt": new_graph.version},
+ "isDeleted": False,
+ },
+ data={"agentGraphVersion": new_graph.version},
)
if count > 0:
logger.info(
- f"Migrated {count} webhook preset(s) for graph #{graph_id} "
- f"to version {new_version} (user #{user_id})"
+ f"Migrated {count} webhook preset(s) for graph #{new_graph.id} "
+ f"to version {new_graph.version} (user #{user_id})"
)
return count
diff --git a/autogpt_platform/backend/backend/api/features/v1.py b/autogpt_platform/backend/backend/api/features/v1.py
index 5ddb29189a..fd6ea2f6c8 100644
--- a/autogpt_platform/backend/backend/api/features/v1.py
+++ b/autogpt_platform/backend/backend/api/features/v1.py
@@ -1792,8 +1792,7 @@ async def update_graph(
if new_graph_version.webhook_input_node:
await library_db.migrate_webhook_presets_to_new_version(
user_id=user_id,
- graph_id=graph_id,
- new_version=new_graph_version.version,
+ new_graph=new_graph_version,
)
new_graph_version_with_subgraphs = await graph_db.get_graph(
@@ -1857,8 +1856,7 @@ async def set_graph_active_version(
if new_active_graph.webhook_input_node:
await library_db.migrate_webhook_presets_to_new_version(
user_id=user_id,
- graph_id=graph_id,
- new_version=new_active_version,
+ new_graph=new_active_graph,
)
diff --git a/autogpt_platform/backend/test/test_migrate_webhook_presets.py b/autogpt_platform/backend/test/test_migrate_webhook_presets.py
index 139d1a1af7..ba1007fc87 100644
--- a/autogpt_platform/backend/test/test_migrate_webhook_presets.py
+++ b/autogpt_platform/backend/test/test_migrate_webhook_presets.py
@@ -40,16 +40,73 @@ def mock_prisma():
yield mock_client
+def _make_graph(
+ *,
+ block_id: str = "trigger-block-a",
+ has_trigger: bool = True,
+ has_config: bool = True,
+ graph_id: str = "graph-abc",
+ version: int = 5,
+):
+ """Stand-in for a GraphModel whose trigger node has a block_id + config."""
+ graph = MagicMock()
+ graph.id = graph_id
+ graph.version = version
+ if not has_trigger:
+ graph.webhook_input_node = None
+ elif not has_config:
+ # Trigger node present but without a webhook_config (defensive branch).
+ graph.webhook_input_node.block.webhook_config = None
+ else:
+ node = MagicMock()
+ node.block_id = block_id
+ node.block.webhook_config = MagicMock() # truthy
+ graph.webhook_input_node = node
+ return graph
+
+
+def _make_preset(preset_id: str, *, version: int = 1):
+ """Stand-in for a prisma AgentPreset row."""
+ preset = MagicMock()
+ preset.id = preset_id
+ preset.agentGraphVersion = version
+ return preset
+
+
+def _patch_old_graphs(mocker, block_id_by_version: dict[int, str | None]):
+ """Patch graph_db.get_graph to return old versions with given trigger blocks.
+
+ A ``None`` value simulates a version that is missing or has no trigger node.
+ """
+
+ async def fake_get_graph(graph_id, version, user_id):
+ block_id = block_id_by_version.get(version)
+ if block_id is None:
+ return None
+ return _make_graph(block_id=block_id, version=version)
+
+ return mocker.patch(
+ "backend.api.features.library.db.graph_db.get_graph",
+ side_effect=fake_get_graph,
+ )
+
+
@pytest.mark.asyncio
-async def test_migrate_updates_matching_presets(mock_prisma):
- mock_prisma.update_many = AsyncMock(return_value=3)
+async def test_migrate_updates_compatible_presets(mock_prisma, mocker):
+ """Presets whose pinned version uses the same trigger block are migrated."""
+ graph = _make_graph(block_id="trigger-a", version=5)
+ mock_prisma.find_many = AsyncMock(
+ return_value=[_make_preset("p1", version=1), _make_preset("p2", version=1)]
+ )
+ mock_prisma.update_many = AsyncMock(return_value=2)
+ _patch_old_graphs(mocker, {1: "trigger-a"})
count = await migrate_webhook_presets_to_new_version(
- user_id="user-123", graph_id="graph-abc", new_version=5
+ user_id="user-123", new_graph=graph
)
- assert count == 3
- mock_prisma.update_many.assert_called_once_with(
+ assert count == 2
+ mock_prisma.find_many.assert_called_once_with(
where={
"userId": "user-123",
"agentGraphId": "graph-abc",
@@ -57,67 +114,188 @@ async def test_migrate_updates_matching_presets(mock_prisma):
"webhookId": {"not": None},
"isDeleted": False,
},
+ )
+ mock_prisma.update_many.assert_called_once_with(
+ where={
+ "id": {"in": ["p1", "p2"]},
+ "userId": "user-123",
+ "agentGraphVersion": {"lt": 5},
+ "isDeleted": False,
+ },
data={"agentGraphVersion": 5},
)
@pytest.mark.asyncio
-async def test_migrate_returns_zero_when_no_matches(mock_prisma):
+async def test_migrate_skips_different_trigger_provider(mock_prisma, mocker):
+ """v1 used a Telegram trigger, v2 uses a GitHub trigger -> do not migrate."""
+ graph = _make_graph(block_id="github-on-pr", version=5)
+ mock_prisma.find_many = AsyncMock(return_value=[_make_preset("p1", version=1)])
+ mock_prisma.update_many = AsyncMock(return_value=0)
+ _patch_old_graphs(mocker, {1: "telegram-on-message"})
+
+ count = await migrate_webhook_presets_to_new_version(
+ user_id="user-123", new_graph=graph
+ )
+
+ assert count == 0
+ mock_prisma.update_many.assert_not_called()
+
+
+async def test_migrate_skips_different_trigger_same_provider(mock_prisma, mocker):
+ """Same provider, different trigger block (on-PR vs on-issue) -> do not migrate."""
+ graph = _make_graph(block_id="github-on-issue", version=5)
+ mock_prisma.find_many = AsyncMock(return_value=[_make_preset("p1", version=1)])
mock_prisma.update_many = AsyncMock(return_value=0)
+ _patch_old_graphs(mocker, {1: "github-on-pr"})
count = await migrate_webhook_presets_to_new_version(
- user_id="user-123", graph_id="graph-abc", new_version=1
+ user_id="user-123", new_graph=graph
)
assert count == 0
+ mock_prisma.update_many.assert_not_called()
@pytest.mark.asyncio
-async def test_migrate_filters_correctly(mock_prisma):
- mock_prisma.update_many = AsyncMock(return_value=1)
+async def test_migrate_only_updates_compatible_in_mixed_set(mock_prisma, mocker):
+ """Compatible presets migrate; incompatible ones are left pinned."""
+ graph = _make_graph(block_id="trigger-a", version=7)
+ mock_prisma.find_many = AsyncMock(
+ return_value=[
+ _make_preset("ok1", version=1),
+ _make_preset("bad", version=2),
+ _make_preset("ok2", version=1),
+ ]
+ )
+ mock_prisma.update_many = AsyncMock(return_value=2)
+ _patch_old_graphs(mocker, {1: "trigger-a", 2: "trigger-b"})
- await migrate_webhook_presets_to_new_version(
- user_id="user-456", graph_id="graph-xyz", new_version=10
+ count = await migrate_webhook_presets_to_new_version(
+ user_id="user-123", new_graph=graph
)
- where = mock_prisma.update_many.call_args.kwargs["where"]
- assert where["webhookId"] == {"not": None}
- assert where["isDeleted"] is False
- assert where["userId"] == "user-456"
- assert where["agentGraphId"] == "graph-xyz"
- # Only strictly older versions should be migrated (not equal, not newer).
- assert where["agentGraphVersion"] == {"lt": 10}
+ assert count == 2
+ mock_prisma.update_many.assert_called_once_with(
+ where={
+ "id": {"in": ["ok1", "ok2"]},
+ "userId": "user-123",
+ "agentGraphVersion": {"lt": 7},
+ "isDeleted": False,
+ },
+ data={"agentGraphVersion": 7},
+ )
@pytest.mark.asyncio
-async def test_migrate_logs_when_presets_are_migrated(mock_prisma, caplog):
+async def test_migrate_returns_zero_when_no_trigger_node(mock_prisma):
+ """No webhook trigger on the new version -> no DB access, returns 0."""
+ graph = _make_graph(has_trigger=False)
+ mock_prisma.find_many = AsyncMock()
+ mock_prisma.update_many = AsyncMock()
+
+ count = await migrate_webhook_presets_to_new_version(
+ user_id="user-123", new_graph=graph
+ )
+
+ assert count == 0
+ mock_prisma.find_many.assert_not_called()
+ mock_prisma.update_many.assert_not_called()
+
+
+async def test_migrate_returns_zero_when_trigger_has_no_webhook_config(mock_prisma):
+ """Trigger node present but without a webhook_config -> no DB access."""
+ graph = _make_graph(has_config=False)
+ mock_prisma.find_many = AsyncMock()
+ mock_prisma.update_many = AsyncMock()
+
+ count = await migrate_webhook_presets_to_new_version(
+ user_id="user-123", new_graph=graph
+ )
+
+ assert count == 0
+ mock_prisma.find_many.assert_not_called()
+ mock_prisma.update_many.assert_not_called()
+
+
+async def test_migrate_skips_preset_when_old_version_unavailable(
+ mock_prisma, mocker, caplog
+):
+ """If the pinned version can't be loaded, treat as incompatible (no downgrade)."""
+ graph = _make_graph(block_id="trigger-a", version=5)
+ mock_prisma.find_many = AsyncMock(return_value=[_make_preset("orphan", version=1)])
+ mock_prisma.update_many = AsyncMock(return_value=0)
+ _patch_old_graphs(mocker, {1: None}) # get_graph returns None
+
+ with caplog.at_level(logging.WARNING, logger="backend.api.features.library.db"):
+ count = await migrate_webhook_presets_to_new_version(
+ user_id="user-123", new_graph=graph
+ )
+
+ assert count == 0
+ mock_prisma.update_many.assert_not_called()
+ assert any(
+ "Not migrating preset #orphan" in record.message for record in caplog.records
+ )
+
+
+async def test_migrate_returns_zero_when_no_candidates(mock_prisma, mocker):
+ graph = _make_graph(version=3)
+ mock_prisma.find_many = AsyncMock(return_value=[])
+ mock_prisma.update_many = AsyncMock()
+ get_graph_mock = _patch_old_graphs(mocker, {})
+
+ count = await migrate_webhook_presets_to_new_version(
+ user_id="user-123", new_graph=graph
+ )
+
+ assert count == 0
+ mock_prisma.update_many.assert_not_called()
+ get_graph_mock.assert_not_called()
+
+
+async def test_migrate_logs_when_presets_are_migrated(mock_prisma, mocker, caplog):
"""Exercise the ``count > 0`` log branch."""
+ graph = _make_graph(block_id="trigger-a", version=4)
+ mock_prisma.find_many = AsyncMock(
+ return_value=[_make_preset("p1", version=1), _make_preset("p2", version=1)]
+ )
mock_prisma.update_many = AsyncMock(return_value=2)
+ _patch_old_graphs(mocker, {1: "trigger-a"})
with caplog.at_level(logging.INFO, logger="backend.api.features.library.db"):
count = await migrate_webhook_presets_to_new_version(
- user_id="user-789", graph_id="graph-log", new_version=4
+ user_id="user-789", new_graph=graph
)
assert count == 2
- # The function logs an INFO message when at least one preset is migrated.
assert any(
"Migrated 2 webhook preset(s)" in record.message for record in caplog.records
)
@pytest.mark.asyncio
-async def test_migrate_does_not_log_when_nothing_changes(mock_prisma, caplog):
- """The ``count > 0`` log branch is skipped when no presets matched."""
+async def test_migrate_warns_on_incompatible_preset(mock_prisma, mocker, caplog):
+ """Incompatible presets emit a warning explaining why they were skipped."""
+ graph = _make_graph(block_id="github-on-pr", version=5)
+ mock_prisma.find_many = AsyncMock(return_value=[_make_preset("bad", version=1)])
mock_prisma.update_many = AsyncMock(return_value=0)
+ _patch_old_graphs(mocker, {1: "telegram-on-message"})
- with caplog.at_level(logging.INFO, logger="backend.api.features.library.db"):
+ with caplog.at_level(logging.WARNING, logger="backend.api.features.library.db"):
count = await migrate_webhook_presets_to_new_version(
- user_id="user-789", graph_id="graph-nolog", new_version=4
+ user_id="user-789", new_graph=graph
)
assert count == 0
- assert not any("Migrated" in record.message for record in caplog.records)
+ assert any(
+ "Not migrating preset #bad" in record.message for record in caplog.records
+ )
# ---------------------------------------------------------------------------
@@ -177,8 +355,7 @@ async def test_update_graph_in_library_migrates_when_webhook_node_present(
migrate_mock.assert_awaited_once_with(
user_id="user-1",
- graph_id=new_graph.id,
- new_version=new_graph.version,
+ new_graph=new_graph,
)
@@ -261,8 +438,7 @@ async def test_v1_update_graph_migrates_when_webhook_node_present(mocker):
migrate_mock.assert_awaited_once_with(
user_id="user-1",
- graph_id=new_graph.id,
- new_version=new_graph.version,
+ new_graph=new_graph,
)
@@ -349,8 +525,7 @@ async def test_v1_set_graph_active_version_migrates_when_webhook_node_present(
migrate_mock.assert_awaited_once_with(
user_id="user-1",
- graph_id=target_graph.id,
- new_version=target_graph.version,
+ new_graph=target_graph,
)