Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

fix(app): preserve roster agent bindings when duplicating workflows (#43827)

林玮 (Jade Lin)07aba61b7347
diff --git a/api/services/app/console_gateway.py b/api/services/app/console_gateway.py
index 824ed46dc50..8e54756880d 100644
--- a/api/services/app/console_gateway.py
+++ b/api/services/app/console_gateway.py
@@ -245,6 +245,7 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):
icon_background=params.icon_background,
app_id=params.app_id,
package=package,
+ preserve_agent_bindings=as_copy,
)
if result.status == ImportStatus.FAILED or (as_copy and result.status == ImportStatus.PENDING):
session.rollback()
@@ -329,6 +330,7 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):
include_secret=options.include_secret,
workflow_id=options.workflow_id,
version_id=options.version_id,
+ preserve_agent_bindings=options.preserve_agent_bindings,
)
return dsl.serialize_export_data(prepared)
diff --git a/api/services/app/console_service.py b/api/services/app/console_service.py
index 9287815319d..8f633d7ed2e 100644
--- a/api/services/app/console_service.py
+++ b/api/services/app/console_service.py
@@ -370,7 +370,9 @@ class ConsoleAppService:
self._apps.set_starred(context, app_id, starred)
def copy(self, context: RequestContext, app_id: str, params: CopyAppParams) -> tuple[Import, AppRecord | None]:
- dsl = self._transfers.export_dsl(context, app_id, AppExportOptions(include_secret=True))
+ dsl = self._transfers.export_dsl(
+ context, app_id, AppExportOptions(include_secret=True, preserve_agent_bindings=True)
+ )
result = self._transfers.import_dsl(
context,
AppImportParams(mode="yaml-content", yaml_content=dsl, **params.model_dump()),
diff --git a/api/services/app_dsl_service.py b/api/services/app_dsl_service.py
index dde4462d456..f2505ddb793 100644
--- a/api/services/app_dsl_service.py
+++ b/api/services/app_dsl_service.py
@@ -1,5 +1,6 @@
import base64
import hashlib
+import json
import logging
import uuid
from collections.abc import Mapping
@@ -35,6 +36,7 @@ from core.workflow.llm_environment_variable import (
resolve_llm_model_config,
should_resolve_llm_model_selector,
)
+from core.workflow.nodes.agent_v2.validators import WorkflowAgentNodeValidator
from core.workflow.nodes.knowledge_retrieval.entities import KnowledgeRetrievalNodeData
from core.workflow.nodes.trigger_schedule.trigger_schedule_node import TriggerScheduleNode
from events.app_event import app_model_config_was_updated, app_was_created
@@ -48,11 +50,12 @@ from graphon.nodes.question_classifier.entities import QuestionClassifierNodeDat
from graphon.nodes.tool.entities import ToolNodeData
from libs.datetime_utils import naive_utc_now
from models import Account, App, AppMode
-from models.agent import AgentScope
+from models.agent import AgentScope, WorkflowAgentBindingType, WorkflowAgentNodeBinding
+from models.agent_config_entities import WorkflowNodeJobConfig
from models.model import AppModelConfig, AppModelConfigDict, IconType, load_annotation_reply_config
from models.workflow import Workflow
-from services.agent.dsl_entities import AgentPackage, make_agent_app_dsl
-from services.agent.dsl_service import AgentDslService
+from services.agent.dsl_entities import AGENT_NODE_JOB_DSL_KEY, AgentPackage, make_agent_app_dsl
+from services.agent.dsl_service import AgentDslService, is_agent_v2_graph
from services.agent.package_resource_exporter import AgentPackageResourceExporter
from services.agent.retirement_service import WorkflowAgentRetirementService
from services.agent.workflow_publish_service import WorkflowAgentPublishService
@@ -146,6 +149,7 @@ class AppDslService:
app_id: str | None = None,
import_app_id: str | None = None,
package: AppImportPackage | None = None,
+ preserve_agent_bindings: bool = False,
) -> Import:
"""Import an App DSL after checking Site entitlements and staging archive resources."""
self._warnings = []
@@ -355,6 +359,7 @@ class AppDslService:
dependencies=check_dependencies_pending_data,
import_app_id=import_app_id,
allow_premium_site_settings=allow_premium_site_settings,
+ preserve_agent_bindings=preserve_agent_bindings,
)
draft_var_srv = WorkflowDraftVariableService(session=self._session)
@@ -594,6 +599,7 @@ class AppDslService:
dependencies: list[PluginDependency] | None = None,
import_app_id: str | None = None,
allow_premium_site_settings: bool = True,
+ preserve_agent_bindings: bool = False,
) -> App:
"""Create a new app or update an existing one."""
app_data = data.get("app", {})
@@ -717,6 +723,9 @@ class AppDslService:
raw_agent_packages = data.get("agent_packages") or {}
if not isinstance(raw_agent_packages, Mapping):
raise ValueError("agent_packages must be a mapping")
+ import_agent_bindings = bool(raw_agent_packages) or (
+ preserve_agent_bindings and is_agent_v2_graph(graph)
+ )
graph_for_sync = AgentDslService.graph_without_package_bindings(graph) if raw_agent_packages else graph
draft_workflow = workflow_service.sync_draft_workflow(
app_model=app,
@@ -727,17 +736,23 @@ class AppDslService:
environment_variables=environment_variables,
conversation_variables=conversation_variables,
session=self._session,
- commit=not raw_agent_packages,
- sync_agent_bindings=not raw_agent_packages,
+ commit=not import_agent_bindings,
+ sync_agent_bindings=not import_agent_bindings,
)
- if raw_agent_packages:
- _, warnings, retirement_candidates = AgentDslService(self._session).import_workflow_packages(
- workflow=draft_workflow,
- portable_graph=graph,
- raw_packages=raw_agent_packages,
- account=account,
- )
- self._warnings.extend(warnings)
+ if import_agent_bindings:
+ retirement_candidates: set[str] = set()
+ if raw_agent_packages:
+ _, warnings, retirement_candidates = AgentDslService(self._session).import_workflow_packages(
+ workflow=draft_workflow,
+ portable_graph=graph,
+ raw_packages=raw_agent_packages,
+ account=account,
+ )
+ self._warnings.extend(warnings)
+ if preserve_agent_bindings:
+ retirement_candidates.update(
+ self._sync_copied_workflow_bindings(workflow=draft_workflow, account_id=account.id)
+ )
WorkflowAgentPublishService.validate_agent_nodes_for_draft_sync(
session=self._session,
draft_workflow=draft_workflow,
@@ -795,6 +810,36 @@ class AppDslService:
raise ValueError("Invalid app mode")
return app
+ @staticmethod
+ def _workflow_agent_bindings(*, workflow: Workflow, session: Session) -> list[WorkflowAgentNodeBinding]:
+ return list(
+ session.scalars(
+ select(WorkflowAgentNodeBinding).where(
+ WorkflowAgentNodeBinding.tenant_id == workflow.tenant_id,
+ WorkflowAgentNodeBinding.app_id == workflow.app_id,
+ WorkflowAgentNodeBinding.workflow_id == workflow.id,
+ WorkflowAgentNodeBinding.workflow_version == workflow.version,
+ )
+ )
+ )
+
+ def _sync_copied_workflow_bindings(self, *, workflow: Workflow, account_id: str) -> set[str]:
+ """Reuse roster Agents while retaining node-owned inline materialization and complete node jobs."""
+ retirement_candidates = WorkflowAgentPublishService.sync_agent_bindings_for_draft(
+ session=self._session, draft_workflow=workflow, account_id=account_id
+ )
+ graph = workflow.graph_dict
+ agent_nodes = dict(WorkflowAgentNodeValidator.iter_agent_v2_nodes(graph))
+ for binding in self._workflow_agent_bindings(workflow=workflow, session=self._session):
+ node_data = agent_nodes.get(binding.node_id)
+ if not isinstance(node_data, dict):
+ continue
+ node_job = node_data.pop(AGENT_NODE_JOB_DSL_KEY, None)
+ if node_job is not None:
+ binding.node_job_config = WorkflowNodeJobConfig.model_validate(node_job)
+ workflow.graph = json.dumps(graph)
+ return retirement_candidates
+
@classmethod
def export_dsl(
cls,
@@ -837,8 +882,9 @@ class AppDslService:
workflow_id: str | None = None,
version_id: uuid.UUID | None = None,
resource_exporter: AgentPackageResourceExporter | None = None,
+ preserve_agent_bindings: bool = False,
) -> AppDslExportData:
- """Load portable App and Site data without requesting plugin dependencies."""
+ """Load App and Site data, optionally retaining roster references for duplication."""
app_mode = AppMode.value_of(app_model.mode)
if app_mode == AppMode.AGENT:
@@ -860,6 +906,7 @@ class AppDslService:
workflow_id=workflow_id,
session=session,
resource_exporter=resource_exporter,
+ preserve_agent_bindings=preserve_agent_bindings,
)
else:
dependencies = cls._append_model_config_export_data(export_data, app_model, session=session)
@@ -891,6 +938,7 @@ class AppDslService:
session: Session,
workflow_id: str | None = None,
resource_exporter: AgentPackageResourceExporter | None = None,
+ preserve_agent_bindings: bool = False,
) -> list[str]:
"""
Append workflow export data
@@ -906,11 +954,42 @@ class AppDslService:
raise WorkflowNotFoundError("Missing draft workflow configuration, please check.")
workflow_dict = workflow.to_dict(include_secret=include_secret)
+ graph = workflow_dict.get("graph", {})
+ reference_nodes: dict[str, dict[str, Any]] = {}
+ if preserve_agent_bindings:
+ graph = WorkflowAgentPublishService.project_draft_bindings_to_graph(
+ session=session, draft_workflow=workflow
+ )
+ agent_nodes = dict(WorkflowAgentNodeValidator.iter_agent_v2_nodes(graph))
+ for binding in cls._workflow_agent_bindings(workflow=workflow, session=session):
+ node_data = agent_nodes.get(binding.node_id)
+ if binding.binding_type != WorkflowAgentBindingType.ROSTER_AGENT or not isinstance(node_data, dict):
+ continue
+ if not binding.agent_id or not binding.current_snapshot_id:
+ raise ValueError(f"Workflow Agent node {binding.node_id} has no complete persisted binding.")
+ node_data[AGENT_NODE_JOB_DSL_KEY] = WorkflowNodeJobConfig.model_validate(
+ binding.node_job_config_dict
+ ).model_dump(mode="json")
+ reference_nodes[binding.node_id] = node_data
+ # Roster Agents are external references of the copied App, so only its inline Agents need packages.
+ graph_for_packages = (
+ {**graph, "nodes": [node for node in graph.get("nodes", []) if node["id"] not in reference_nodes]}
+ if reference_nodes
+ else graph
+ )
graph, agent_packages = AgentDslService(session).export_workflow_packages(
workflow=workflow,
- graph=workflow_dict.get("graph", {}),
+ graph=graph_for_packages,
resource_exporter=resource_exporter,
)
+ if reference_nodes:
+ packaged_nodes = {node["id"]: node for node in graph["nodes"]}
+ graph["nodes"] = [
+ {**node, "data": reference_nodes[node["id"]]}
+ if node["id"] in reference_nodes
+ else packaged_nodes[node["id"]]
+ for node in workflow.graph_dict.get("nodes", [])
+ ]
workflow_dict["graph"] = graph
# TODO: refactor: we need a better way to filter workspace related data from nodes
for node in workflow_dict.get("graph", {}).get("nodes", []):
diff --git a/api/services/entities/app_entities.py b/api/services/entities/app_entities.py
index d67ed4f3433..f77ba9cbcb3 100644
--- a/api/services/entities/app_entities.py
+++ b/api/services/entities/app_entities.py
@@ -174,6 +174,7 @@ class AppExportOptions:
include_secret: bool = False
workflow_id: str | None = None
version_id: UUID | None = None
+ preserve_agent_bindings: bool = False
@dataclass(frozen=True, slots=True)
diff --git a/api/tests/unit_tests/services/app/test_console_gateway.py b/api/tests/unit_tests/services/app/test_console_gateway.py
index 0006a88816b..063f98c0e7a 100644
--- a/api/tests/unit_tests/services/app/test_console_gateway.py
+++ b/api/tests/unit_tests/services/app/test_console_gateway.py
@@ -1,5 +1,6 @@
"""Policy and existing DSL adapters retain their domain-specific behavior."""
+import json
from collections.abc import Callable, Generator, Iterator
from typing import cast
from unittest.mock import Mock
@@ -18,8 +19,21 @@ from enums import CloudPlan, DeploymentEdition
from extensions.application_services.app import AppServices
from machinery.context import RequestContext
from models.account import Account, TenantAccountJoin, TenantAccountRole
+from models.agent import (
+ Agent,
+ AgentConfigRevision,
+ AgentConfigRevisionOperation,
+ AgentConfigSnapshot,
+ AgentScope,
+ AgentSource,
+ AgentStatus,
+ WorkflowAgentBindingType,
+ WorkflowAgentNodeBinding,
+)
+from models.agent_config_entities import AgentSoulConfig
from models.model import App, AppMode, AppModelConfig, IconType
from models.workflow import Workflow, WorkflowType
+from services.agent.dsl_entities import AGENT_PACKAGE_REF_KEY
from services.agent.package_resource_exporter import AgentPackageResourceExporter
from services.agent.roster_package_exporter import RosterAgentPackageExporter
from services.agent.roster_package_importer import RosterAgentPackageImporter
@@ -42,6 +56,193 @@ from tests.unit_tests.model_factories import make_account, make_tenant, make_upl
from tests.unit_tests.rbac_fakes import RBACDomain
[email protected](("mode", "include_inline"), [(AppMode.WORKFLOW, False), (AppMode.ADVANCED_CHAT, True)])
+def test_copy_preserves_shared_roster_bindings_and_clones_owned_inline_agents(
+ app_services: AppServices,
+ sqlite_session_factory: sessionmaker[Session],
+ copy_source: tuple[RequestContext, str],
+ monkeypatch: pytest.MonkeyPatch,
+ mode: AppMode,
+ include_inline: bool,
+) -> None:
+ context, app_id = copy_source
+ tenant_id, actor_id = context.active_workspace_id, context.account_id
+ workflow_id, roster_id, roster_snapshot_id, inline_id, inline_snapshot_id = [str(uuid4()) for _ in range(5)]
+ node_ids = ["roster-1", "roster-2"] + (["inline"] if include_inline else [])
+ graph = {
+ "nodes": [
+ {
+ "id": node_id,
+ "data": {"type": "agent", "title": node_id, "version": "2", "agent_node_kind": "dify_agent"},
+ }
+ for node_id in node_ids
+ ],
+ "edges": list[dict[str, str]](),
+ }
+ with sqlite_session_factory.begin() as session:
+ source_app = session.get(App, app_id)
+ assert source_app is not None
+ source_app.mode = mode
+ source_workflow = Workflow(
+ id=workflow_id,
+ tenant_id=tenant_id,
+ app_id=app_id,
+ type=WorkflowType.from_app_mode(mode).value,
+ version=Workflow.VERSION_DRAFT,
+ graph=json.dumps(graph),
+ features=json.dumps({}),
+ environment_variables=[],
+ conversation_variables=[],
+ created_by=actor_id,
+ )
+ roster = Agent(
+ id=roster_id,
+ tenant_id=tenant_id,
+ name="Shared roster",
+ scope=AgentScope.ROSTER,
+ source=AgentSource.AGENT_APP,
+ status=AgentStatus.ACTIVE,
+ active_config_snapshot_id=roster_snapshot_id,
+ active_config_is_published=True,
+ )
+ session.add_all(
+ [
+ source_workflow,
+ roster,
+ AgentConfigSnapshot(
+ id=roster_snapshot_id,
+ tenant_id=tenant_id,
+ agent_id=roster_id,
+ version=1,
+ config_snapshot=AgentSoulConfig(config_note="Roster configuration"),
+ created_by=actor_id,
+ ),
+ AgentConfigRevision(
+ tenant_id=tenant_id,
+ agent_id=roster_id,
+ current_snapshot_id=roster_snapshot_id,
+ revision=1,
+ operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,
+ created_by=actor_id,
+ ),
+ ]
+ )
+ if include_inline:
+ session.add_all(
+ [
+ Agent(
+ id=inline_id,
+ tenant_id=tenant_id,
+ name="Owned inline",
+ scope=AgentScope.WORKFLOW_ONLY,
+ source=AgentSource.WORKFLOW,
+ status=AgentStatus.ACTIVE,
+ app_id=app_id,
+ workflow_id=workflow_id,
+ workflow_node_id="inline",
+ active_config_snapshot_id=inline_snapshot_id,
+ ),
+ AgentConfigSnapshot(
+ id=inline_snapshot_id,
+ tenant_id=tenant_id,
+ agent_id=inline_id,
+ version=1,
+ config_snapshot=AgentSoulConfig(config_note="Inline configuration"),
+ created_by=actor_id,
+ ),
+ ]
+ )
+ for node_id in node_ids:
+ is_inline = node_id == "inline"
+ session.add(
+ WorkflowAgentNodeBinding(
+ tenant_id=tenant_id,
+ app_id=app_id,
+ workflow_id=workflow_id,
+ workflow_version=Workflow.VERSION_DRAFT,
+ node_id=node_id,
+ binding_type=(
+ WorkflowAgentBindingType.INLINE_AGENT if is_inline else WorkflowAgentBindingType.ROSTER_AGENT
+ ),
+ agent_id=inline_id if is_inline else roster_id,
+ current_snapshot_id=inline_snapshot_id if is_inline else roster_snapshot_id,
+ node_job_config={
+ "workflow_prompt": f"Task for {node_id}",
+ "mode": "let_agent_figure_it_out",
+ "output_routes": {"enabled": False, "routes": [{"id": "route-1", "name": "Continue"}]},
+ },
+ created_by=actor_id,
+ )
+ )
+ monkeypatch.setattr(DependenciesAnalysisService, "generate_dependencies", lambda **_kwargs: [])
+ monkeypatch.setattr(SystemFeatureService, "is_webapp_auth_enabled", lambda: False)
+ workflow_service = WorkflowService(session_maker=sqlite_session_factory)
+ monkeypatch.setattr("services.app_dsl_service.WorkflowService", lambda: workflow_service)
+
+ exported = app_services.console.export(context, app_id, AppExportOptions(format="yaml"))
+ assert isinstance(exported, str)
+ portable = yaml.safe_load(exported)
+ assert all(
+ AGENT_PACKAGE_REF_KEY in node["data"]["agent_binding"] for node in portable["workflow"]["graph"]["nodes"]
+ )
+
+ result, copied = app_services.console.copy(context, app_id, CopyAppParams(name="Copy"))
+ assert result.status == ImportStatus.COMPLETED
+ assert copied is not None
+ assert copied.id != app_id
+ with sqlite_session_factory() as session:
+ copied_workflow = session.scalar(select(Workflow).where(Workflow.app_id == copied.id))
+ assert copied_workflow is not None
+ assert copied_workflow.version == Workflow.VERSION_DRAFT
+ bindings = {
+ binding.node_id: binding
+ for binding in session.scalars(
+ select(WorkflowAgentNodeBinding).where(WorkflowAgentNodeBinding.workflow_id == copied_workflow.id)
+ )
+ }
+ assert set(bindings) == set(node_ids)
+ source_jobs = {
+ binding.node_id: binding.node_job_config_dict
+ for binding in session.scalars(
+ select(WorkflowAgentNodeBinding).where(WorkflowAgentNodeBinding.workflow_id == workflow_id)
+ )
+ }
+ for node_id in ("roster-1", "roster-2"):
+ assert bindings[node_id].binding_type == WorkflowAgentBindingType.ROSTER_AGENT
+ assert bindings[node_id].agent_id == roster_id
+ assert bindings[node_id].current_snapshot_id == roster_snapshot_id
+ for node_id in node_ids:
+ assert bindings[node_id].node_job_config_dict == source_jobs[node_id]
+ if include_inline:
+ binding = bindings["inline"]
+ assert binding.binding_type == WorkflowAgentBindingType.INLINE_AGENT
+ assert binding.agent_id != inline_id
+ assert binding.current_snapshot_id != inline_snapshot_id
+ cloned_agent = session.get(Agent, binding.agent_id)
+ assert cloned_agent is not None
+ assert cloned_agent.scope == AgentScope.WORKFLOW_ONLY
+ assert cloned_agent.app_id == copied.id
+ assert cloned_agent.workflow_id == copied_workflow.id
+ cloned_snapshot = session.get(AgentConfigSnapshot, binding.current_snapshot_id)
+ assert cloned_snapshot is not None
+ assert cloned_snapshot.config_snapshot_dict["config_note"] == "Inline configuration"
+ assert len(list(session.scalars(select(Agent).where(Agent.scope == AgentScope.ROSTER)))) == 1
+ assert session.scalar(select(Workflow.graph).where(Workflow.id == workflow_id)) == source_workflow.graph
+ expected_app_ids = set(session.scalars(select(App.id)))
+ expected_workflow_ids = set(session.scalars(select(Workflow.id)))
+ source_agent = session.get(Agent, roster_id)
+ assert source_agent is not None
+ source_agent.tenant_id = str(uuid4())
+ session.commit()
+
+ failed, failed_copy = app_services.console.copy(context, app_id, CopyAppParams(name="Invalid copy"))
+ assert failed.status == ImportStatus.FAILED
+ assert failed_copy is None
+ with sqlite_session_factory() as session:
+ assert set(session.scalars(select(App.id))) == expected_app_ids
+ assert set(session.scalars(select(Workflow.id))) == expected_workflow_ids
+
+
@pytest.fixture
def copy_source(sqlite_session_factory: sessionmaker[Session]) -> tuple[RequestContext, str]:
actor, workspace, app_id = str(uuid4()), str(uuid4()), str(uuid4())
diff --git a/api/tests/unit_tests/services/app/test_console_service.py b/api/tests/unit_tests/services/app/test_console_service.py
index 75eb694c9e8..94030e89eae 100644
--- a/api/tests/unit_tests/services/app/test_console_service.py
+++ b/api/tests/unit_tests/services/app/test_console_service.py
@@ -340,7 +340,7 @@ def test_copy_success_requires_materialized_app_and_enriches_permissions(ports:
assert access.calls == [("inherit", "app", "app"), ("created_permissions", CONTEXT, "app")]
assert apps.calls == [("get", CONTEXT, "app")]
assert transfers.calls == [
- ("dsl", CONTEXT, "app", AppExportOptions(include_secret=True)),
+ ("dsl", CONTEXT, "app", AppExportOptions(include_secret=True, preserve_agent_bindings=True)),
(
"import",
CONTEXT,