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.

feat(api): keep roster Agent links through app package export and import on request (#44550)

Xiyuan Chen3dd0ded122de
diff --git a/api/services/agent/workflow_publish_service.py b/api/services/agent/workflow_publish_service.py
index 755547fd2ac..0e8e866da25 100644
--- a/api/services/agent/workflow_publish_service.py
+++ b/api/services/agent/workflow_publish_service.py
@@ -60,8 +60,13 @@ class WorkflowAgentPublishService:
_AGENT_OUTPUT_ROUTES_KEY = "agent_output_routes"
@classmethod
- def project_draft_bindings_to_graph(cls, *, session: Session, draft_workflow: Workflow) -> dict[str, Any]:
- """Return draft graph with persisted Agent binding fields projected into node data.
+ def project_draft_bindings_to_graph(
+ cls, *, session: Session, draft_workflow: Workflow, binding_version: str = Workflow.VERSION_DRAFT
+ ) -> dict[str, Any]:
+ """Return the workflow graph with persisted Agent binding fields projected into node data.
+
+ Reads the binding rows of ``binding_version``. The default is the draft;
+ a DSL export passes the exported workflow's own version.
Workflow draft graph is the front-end's editing source of truth, while
runtime/publish reads WorkflowAgentNodeBinding. This
@@ -78,7 +83,7 @@ class WorkflowAgentPublishService:
WorkflowAgentNodeBinding.tenant_id == draft_workflow.tenant_id,
WorkflowAgentNodeBinding.app_id == draft_workflow.app_id,
WorkflowAgentNodeBinding.workflow_id == draft_workflow.id,
- WorkflowAgentNodeBinding.workflow_version == cls._DRAFT_WORKFLOW_VERSION,
+ WorkflowAgentNodeBinding.workflow_version == binding_version,
WorkflowAgentNodeBinding.node_id.in_(list(agent_nodes.keys())),
)
).all()
diff --git a/api/services/app/console_gateway.py b/api/services/app/console_gateway.py
index 5a9730f6bc4..8ba6723ea22 100644
--- a/api/services/app/console_gateway.py
+++ b/api/services/app/console_gateway.py
@@ -79,6 +79,9 @@ from tasks.initialize_created_app_rbac_access_task import initialize_created_app
# NODE_WIDTH_X_OFFSET in web/app/components/workflow/constants.ts).
_START_POSITION: Final = (80, 282)
_NODE_X_STEP: Final = 300
+_DISCARDED_IMPORT_STATUSES: Final = frozenset({ImportStatus.FAILED})
+# A copy that waits for version confirmation keeps nothing.
+_DISCARDED_COPY_STATUSES: Final = frozenset({ImportStatus.FAILED, ImportStatus.PENDING})
def _editor_node(node_id: str, column: int, data: dict[str, Any]) -> dict[str, Any]:
@@ -295,8 +298,31 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):
context: RequestContext,
params: AppImportParams,
*,
- as_copy: bool = False,
package: AppImportPackage | None = None,
+ preserve_agent_bindings: bool = False,
+ ) -> Import:
+ return self._import(
+ context,
+ params,
+ package=package,
+ preserve_agent_bindings=preserve_agent_bindings,
+ discarded=_DISCARDED_IMPORT_STATUSES,
+ )
+
+ @override
+ def import_copy(self, context: RequestContext, params: AppImportParams) -> Import:
+ return self._import(
+ context, params, package=None, preserve_agent_bindings=True, discarded=_DISCARDED_COPY_STATUSES
+ )
+
+ def _import(
+ self,
+ context: RequestContext,
+ params: AppImportParams,
+ *,
+ package: AppImportPackage | None,
+ preserve_agent_bindings: bool,
+ discarded: frozenset[ImportStatus],
) -> Import:
account = self._import_actor(context)
with self._session_factory() as session:
@@ -312,10 +338,10 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):
icon_background=params.icon_background,
app_id=params.app_id,
package=package,
- preserve_agent_bindings=as_copy,
+ preserve_agent_bindings=preserve_agent_bindings,
draft_hash=params.draft_hash if isinstance(params, DraftGuardedImportParams) else None,
)
- if result.status == ImportStatus.FAILED or (as_copy and result.status == ImportStatus.PENDING):
+ if result.status in discarded:
session.rollback()
else:
session.commit()
@@ -411,7 +437,10 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):
with self._session_factory() as session:
app = require_console_app(session, context, app_id)
return self._packages.export_app(
- app_model=app, include_secret=options.include_secret, workflow_id=options.workflow_id
+ app_model=app,
+ include_secret=options.include_secret,
+ workflow_id=options.workflow_id,
+ preserve_agent_bindings=options.preserve_agent_bindings,
)
@override
diff --git a/api/services/app/console_service.py b/api/services/app/console_service.py
index c01462daf0f..56b9e6af375 100644
--- a/api/services/app/console_service.py
+++ b/api/services/app/console_service.py
@@ -134,10 +134,12 @@ class AppTransfers(Protocol):
context: RequestContext,
params: AppImportParams,
*,
- as_copy: bool = False,
package: AppImportPackage | None = None,
+ preserve_agent_bindings: bool = False,
) -> Import: ...
+ def import_copy(self, context: RequestContext, params: AppImportParams) -> Import: ...
+
def confirm_import(self, context: RequestContext, import_id: str) -> tuple[Import, bool]: ...
def import_agent_package(self, context: RequestContext, source: BinaryIO) -> ImportedAppPackage: ...
@@ -413,10 +415,8 @@ class ConsoleAppService:
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()),
- as_copy=True,
+ result = self._transfers.import_copy(
+ context, AppImportParams(mode="yaml-content", yaml_content=dsl, **params.model_dump())
)
if result.status in {ImportStatus.FAILED, ImportStatus.PENDING}:
return result, None
diff --git a/api/services/app/import_service.py b/api/services/app/import_service.py
index 4d327153db1..dbd1300754f 100644
--- a/api/services/app/import_service.py
+++ b/api/services/app/import_service.py
@@ -12,7 +12,9 @@ class ImportAccounts(Protocol):
class AppDefinitionImports(Protocol):
- def import_dsl(self, context: RequestContext, params: AppImportParams) -> Import: ...
+ def import_dsl(
+ self, context: RequestContext, params: AppImportParams, *, preserve_agent_bindings: bool = False
+ ) -> Import: ...
def confirm_definition(self, context: RequestContext, import_id: str) -> Import: ...
@@ -24,8 +26,10 @@ class AppImportService:
self._accounts = accounts
self._definitions = definitions
- def import_app(self, context: RequestContext, params: AppImportParams) -> Import:
- return self._definitions.import_dsl(context, params)
+ def import_app(
+ self, context: RequestContext, params: AppImportParams, *, preserve_agent_bindings: bool = False
+ ) -> Import:
+ return self._definitions.import_dsl(context, params, preserve_agent_bindings=preserve_agent_bindings)
def import_as_creator(
self,
diff --git a/api/services/app_dsl_service.py b/api/services/app_dsl_service.py
index 79565433f8d..db2d9113828 100644
--- a/api/services/app_dsl_service.py
+++ b/api/services/app_dsl_service.py
@@ -144,6 +144,7 @@ class PendingData(PendingImportOwner):
icon_background: str | None = None
app_id: str | None = None
draft_hash: str | None = None
+ preserve_agent_bindings: bool = False
warnings: list[DslImportWarning] = Field(default_factory=list)
@@ -364,6 +365,7 @@ class AppDslService:
icon_background=icon_background,
app_id=app_id,
draft_hash=draft_hash,
+ preserve_agent_bindings=preserve_agent_bindings,
warnings=self._warnings,
)
redis_client.setex(
@@ -515,6 +517,7 @@ class AppDslService:
icon_background=pending_data.icon_background,
allow_premium_site_settings=allow_premium_site_settings,
draft_hash=pending_data.draft_hash,
+ preserve_agent_bindings=pending_data.preserve_agent_bindings,
)
# Delete import info from Redis
@@ -1054,7 +1057,9 @@ class AppDslService:
reference_nodes: dict[str, dict[str, Any]] = {}
if preserve_agent_bindings:
graph = WorkflowAgentPublishService.project_draft_bindings_to_graph(
- session=session, draft_workflow=workflow
+ session=session,
+ draft_workflow=workflow,
+ binding_version=workflow.version,
)
agent_nodes = dict(WorkflowAgentNodeValidator.iter_agent_v2_nodes(graph))
for binding in cls._workflow_agent_bindings(workflow=workflow, session=session):
diff --git a/api/services/app_package_service.py b/api/services/app_package_service.py
index f1818408beb..b4e7e8a219c 100644
--- a/api/services/app_package_service.py
+++ b/api/services/app_package_service.py
@@ -7,7 +7,7 @@ import re
import tempfile
import zipfile
import zlib
-from collections.abc import Iterator
+from collections.abc import Iterator, Mapping
from dataclasses import dataclass, field
from typing import Any, BinaryIO, Literal, Self, cast
@@ -18,8 +18,8 @@ from core.db.session_factory import session_factory
from core.workflow.nodes.agent_v2.validators import WorkflowAgentNodeValidator
from models.agent import WorkflowAgentBindingType
from models.agent_config_entities import WorkflowNodeJobConfig
-from models.model import App
-from services.agent.dsl_entities import AgentPackage
+from models.model import App, AppMode
+from services.agent.dsl_entities import AGENT_NODE_JOB_DSL_KEY, AGENT_PACKAGE_REF_KEY, AgentPackage
from services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError
from services.agent.package_resource_exporter import AgentPackageResourceExporter
from services.agent.package_resource_importer import AgentPackageResourceImporter
@@ -39,6 +39,8 @@ from services.dsl_content import DSL_MAX_SIZE
from services.entities.dsl_entities import DslImportWarning
from services.entities.site_dsl import SiteDsl
+_AGENT_ID_KEY = "agent_id"
+
class AppPackageManifest(BaseModel):
"""Index Agent resources by the same package references used in the workflow DSL."""
@@ -114,7 +116,7 @@ class PreparedAppPackage(PreparedPackageArchive):
class AppPackageService(RosterAgentPackageReader):
"""Reuse the bounded ZIP reader; Apps retain DSL import semantics."""
- def read_package(self, source: BinaryIO) -> PreparedAppPackage | None:
+ def read_package(self, source: BinaryIO, *, accept_roster_references: bool = False) -> PreparedAppPackage | None:
"""Validate an App archive, or rewind a Roster package for its importer."""
spool = cast(BinaryIO, tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b")) # noqa: SIM115
try:
@@ -145,7 +147,7 @@ class AppPackageService(RosterAgentPackageReader):
not in {"workflow", "advanced-chat", "chat", "completion", "agent-chat", "channel", "rag-pipeline"}
):
raise InvalidRosterAgentPackageError("App package DSL is invalid")
- agents = self._validate_agents(app_data, manifest)
+ agents = self._validate_agents(app_data, manifest, accept_roster_references=accept_roster_references)
site_data = app_data.get("site")
if site_data is not None:
try:
@@ -197,23 +199,37 @@ class AppPackageService(RosterAgentPackageReader):
finally:
source.seek(0)
- @staticmethod
- def _validate_agents(data: dict[str, Any], manifest: AppPackageManifest) -> dict[str, AgentPackage]:
+ @classmethod
+ def _validate_agents(
+ cls, data: dict[str, Any], manifest: AppPackageManifest, *, accept_roster_references: bool
+ ) -> dict[str, AgentPackage]:
+ agent_modes = {AppMode.WORKFLOW, AppMode.ADVANCED_CHAT}
if not manifest.agent_resources:
- return {}
+ if not accept_roster_references:
+ return {}
+ if data["app"]["mode"] not in agent_modes:
+ return {}
try:
- if data["app"]["mode"] not in {"workflow", "advanced-chat"}:
+ if data["app"]["mode"] not in agent_modes:
raise ValueError("Agent resources require a workflow App")
- agents = {ref: AgentPackage.model_validate(value) for ref, value in data["agent_packages"].items()}
+ packages = (data.get("agent_packages") or {}) if accept_roster_references else data["agent_packages"]
+ agents = {ref: AgentPackage.model_validate(value) for ref, value in packages.items()}
references: set[str] = set()
for _, node_data in WorkflowAgentNodeValidator.iter_agent_v2_nodes(data["workflow"]["graph"]):
binding = node_data["agent_binding"]
- WorkflowAgentBindingType(binding["binding_type"])
- reference = binding["package_ref"]
+ binding_type = WorkflowAgentBindingType(binding["binding_type"])
+ if accept_roster_references:
+ if cls._is_roster_reference(binding_type, binding):
+ cls._validate_roster_reference(binding, node_data)
+ continue
+ if binding_type == WorkflowAgentBindingType.ROSTER_AGENT:
+ if binding.get(_AGENT_ID_KEY) is not None:
+ raise ValueError("Agent binding cannot be both packaged and a roster reference")
+ reference = binding[AGENT_PACKAGE_REF_KEY]
if not isinstance(reference, str):
raise ValueError("Agent package reference must be a string")
references.add(reference)
- WorkflowNodeJobConfig.model_validate(node_data.get("agent_job") or {})
+ WorkflowNodeJobConfig.model_validate(node_data.get(AGENT_NODE_JOB_DSL_KEY) or {})
if set(agents) != set(manifest.agent_resources) or references != set(agents):
raise ValueError("Agent resources must match workflow package references")
for ref, group in manifest.agent_resources.items():
@@ -222,8 +238,28 @@ class AppPackageService(RosterAgentPackageReader):
except (KeyError, TypeError, AttributeError, ValueError) as exc:
raise InvalidRosterAgentPackageError("App package Agent references are invalid") from exc
+ @staticmethod
+ def _is_roster_reference(binding_type: WorkflowAgentBindingType, binding: Mapping[str, Any]) -> bool:
+ if binding_type != WorkflowAgentBindingType.ROSTER_AGENT:
+ return False
+ return AGENT_PACKAGE_REF_KEY not in binding
+
+ @staticmethod
+ def _validate_roster_reference(binding: Mapping[str, Any], node_data: Mapping[str, Any]) -> None:
+ agent_id = binding.get(_AGENT_ID_KEY)
+ if not isinstance(agent_id, str):
+ raise ValueError("Roster Agent reference requires an agent id")
+ if not agent_id:
+ raise ValueError("Roster Agent reference requires an agent id")
+ WorkflowNodeJobConfig.model_validate(node_data.get(AGENT_NODE_JOB_DSL_KEY) or {})
+
def export_app(
- self, *, app_model: App, include_secret: bool = False, workflow_id: str | None = None
+ self,
+ *,
+ app_model: App,
+ include_secret: bool = False,
+ workflow_id: str | None = None,
+ preserve_agent_bindings: bool = False,
) -> RosterAgentPackageExport:
from services.app_dsl_service import AppDslService
@@ -235,6 +271,7 @@ class AppPackageService(RosterAgentPackageReader):
include_secret=include_secret,
workflow_id=workflow_id,
resource_exporter=resources,
+ preserve_agent_bindings=preserve_agent_bindings,
)
resources.collect_icon(session=session, tenant_id=app_model.tenant_id, metadata=prepared.data["app"])
if isinstance(prepared.data.get("site"), dict):
@@ -244,10 +281,20 @@ class AppPackageService(RosterAgentPackageReader):
prepared.data["agent_packages"] = {
ref: package.model_dump(mode="json") for ref, package in resources.packages.items()
}
- return self.export(dsl=AppDslService.serialize_export_data(prepared), name=app_model.name, resources=resources)
+ return self.export(
+ dsl=AppDslService.serialize_export_data(prepared),
+ name=app_model.name,
+ resources=resources,
+ accept_roster_references=preserve_agent_bindings,
+ )
def export(
- self, *, dsl: str, name: str, resources: AgentPackageResourceExporter | None = None
+ self,
+ *,
+ dsl: str,
+ name: str,
+ resources: AgentPackageResourceExporter | None = None,
+ accept_roster_references: bool = False,
) -> RosterAgentPackageExport:
payload = dsl.encode("utf-8")
if len(payload) > DSL_MAX_SIZE:
@@ -275,7 +322,7 @@ class AppPackageService(RosterAgentPackageReader):
size = archive.tell()
archive.seek(0)
# Validate exported containers against the same limits as imports.
- validated = self.read_package(archive)
+ validated = self.read_package(archive, accept_roster_references=accept_roster_references)
if validated is None:
raise InvalidRosterAgentPackageError("Expected an App package")
validated.close()
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 b6017c47379..02abe96505b 100644
--- a/api/tests/unit_tests/services/app/test_console_gateway.py
+++ b/api/tests/unit_tests/services/app/test_console_gateway.py
@@ -754,6 +754,50 @@ def test_dsl_import_forwards_only_a_guarded_draft_hash(
assert forwarded == [draft_hash]
+ ("enter", "expected"),
+ [
+ (
+ lambda services, context, _app_id, params: services.imports.import_app(
+ context, params, preserve_agent_bindings=True
+ ),
+ [True],
+ ),
+ (lambda services, context, _app_id, params: services.console.import_app(context, params), [False]),
+ (
+ lambda services, context, app_id, _params: services.console.copy(
+ context, app_id, CopyAppParams(name="Copy")
+ ),
+ [True],
+ ),
+ ],
+ ids=["imports-on", "console", "copy"],
+)
+def test_import_forwards_preserve_agent_bindings_per_entry(
+ app_services: AppServices,
+ copy_source: tuple[RequestContext, str],
+ monkeypatch: pytest.MonkeyPatch,
+ config_overrides: Callable[..., None],
+ enter: Callable[[AppServices, RequestContext, str, AppImportParams], object],
+ expected: list[bool],
+) -> None:
+ monkeypatch.setattr(DependenciesAnalysisService, "generate_dependencies", lambda **_kwargs: [])
+ config_overrides(RBAC_ENABLED=False, DEPLOYMENT_EDITION="COMMUNITY")
+ context, app_id = copy_source
+ forwarded: list[bool] = []
+
+ def import_app(_dsl: AppDslService, *, preserve_agent_bindings: bool, **_kwargs: object) -> Import:
+ forwarded.append(preserve_agent_bindings)
+ return Import(id="import-1", status=ImportStatus.FAILED)
+
+ monkeypatch.setattr(AppDslService, "import_app", import_app)
+ params = AppImportParams(mode="yaml-content", yaml_content="kind: app\n")
+
+ enter(app_services, context, app_id, params)
+
+ assert forwarded == expected
+
+
@pytest.mark.parametrize("mode", [AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
def test_create_draft_saves_the_starter_graph_of_the_apps_mode(
sqlite_session_factory: sessionmaker[Session],
@@ -863,20 +907,38 @@ def test_import_creator_access_runs_after_successful_commit(
agent_importer=RosterAgentPackageImporter(),
recommended_packages=RecommendedAppPackageService(sources=Mock(), exporter=Mock()),
)
+ import_entry = gateway.import_copy if entry == "copy" else gateway.import_dsl
if commit_fails and status != ImportStatus.FAILED and not (entry == "copy" and status == ImportStatus.PENDING):
if entry == "confirm":
with pytest.raises(RuntimeError, match="commit failed"):
gateway.confirm_import(context, "import")
else:
with pytest.raises(RuntimeError, match="commit failed"):
- gateway.import_dsl(context, AppImportParams(mode="yaml-content"), as_copy=entry == "copy")
+ import_entry(context, AppImportParams(mode="yaml-content"))
assert "sync" not in events
return
if entry == "confirm":
returned, was_created = gateway.confirm_import(context, "import")
assert was_created is created
else:
- returned = gateway.import_dsl(context, AppImportParams(mode="yaml-content"), as_copy=entry == "copy")
+ returned = import_entry(context, AppImportParams(mode="yaml-content"))
assert returned is result
expected = created and status in (ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS)
assert (events.count("sync") == 1) is expected
+
+
+def test_console_package_export_forwards_roster_options(
+ app_services: AppServices,
+ copy_source: tuple[RequestContext, str],
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ context, app_id = copy_source
+ captured: dict[str, object] = {}
+
+ def export_app(_self: AppPackageService, **kwargs: object) -> object:
+ captured.update(kwargs)
+ return object()
+
+ monkeypatch.setattr(AppPackageService, "export_app", export_app)
+ app_services.console.export(context, app_id, AppExportOptions(format="ifpkg", preserve_agent_bindings=True))
+ assert captured["preserve_agent_bindings"] is True
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 7e0f00317f4..440d360ae76 100644
--- a/api/tests/unit_tests/services/app/test_console_service.py
+++ b/api/tests/unit_tests/services/app/test_console_service.py
@@ -199,11 +199,15 @@ class Transfers:
context: RequestContext,
params: AppImportParams,
*,
- as_copy: bool = False,
package: AppImportPackage | None = None,
+ preserve_agent_bindings: bool = False,
) -> Import:
assert package is None
- self.calls.append(("import", context, params, as_copy))
+ self.calls.append(("import", context, params, preserve_agent_bindings))
+ return Import(id="import", status=self.status, app_id=self.copied_id)
+
+ def import_copy(self, context: RequestContext, params: AppImportParams) -> Import:
+ self.calls.append(("copy", context, params))
return Import(id="import", status=self.status, app_id=self.copied_id)
def export_dsl(self, context: RequestContext, app_id: str, options: AppExportOptions) -> str:
@@ -352,10 +356,9 @@ def test_copy_success_requires_materialized_app_and_enriches_permissions(ports:
assert transfers.calls == [
("dsl", CONTEXT, "app", AppExportOptions(include_secret=True, preserve_agent_bindings=True)),
(
- "import",
+ "copy",
CONTEXT,
AppImportParams(mode="yaml-content", yaml_content="app: example", **params.model_dump()),
- True,
),
]
transfers.copied_id = None
@@ -839,17 +842,8 @@ def test_detail_tool_enrichment_releases_database_before_plugin_io(
class CopyTransfer(Transfers):
@override
- def import_dsl(
- self,
- context: RequestContext,
- params: AppImportParams,
- *,
- as_copy: bool = False,
- package: AppImportPackage | None = None,
- ) -> Import:
- assert package is None
+ def import_copy(self, context: RequestContext, params: AppImportParams) -> Import:
assert params.name is None
- assert as_copy
return Import(id="import", status=ImportStatus.COMPLETED, app_id=app.id)
service = ConsoleAppService(
diff --git a/api/tests/unit_tests/services/test_app_package_service.py b/api/tests/unit_tests/services/test_app_package_service.py
index 2b7f72a6ec8..25f53b41986 100644
--- a/api/tests/unit_tests/services/test_app_package_service.py
+++ b/api/tests/unit_tests/services/test_app_package_service.py
@@ -2,8 +2,9 @@ from __future__ import annotations
import hashlib
import io
+import json
import zipfile
-from collections.abc import Callable, Generator
+from collections.abc import Callable, Generator, Mapping
from types import SimpleNamespace
from typing import cast
from unittest.mock import MagicMock, Mock
@@ -215,8 +216,15 @@ def _account(tenant_id: str = "tenant-2") -> Account:
return make_account(tenant=make_tenant(tenant_id=tenant_id))
-def _import(session: Session, content: bytes, *, app_id: str | None = None, account: Account | None = None) -> Import:
- prepared = AppPackageService().read_package(io.BytesIO(content))
+def _import(
+ session: Session,
+ content: bytes,
+ *,
+ app_id: str | None = None,
+ account: Account | None = None,
+ preserve_agent_bindings: bool = False,
+) -> Import:
+ prepared = AppPackageService().read_package(io.BytesIO(content), accept_roster_references=preserve_agent_bindings)
assert prepared is not None
with prepared:
result = AppDslService(session).import_app(
@@ -225,6 +233,7 @@ def _import(session: Session, content: bytes, *, app_id: str | None = None, acco
yaml_content=prepared.dsl,
app_id=app_id,
package=prepared,
+ preserve_agent_bindings=preserve_agent_bindings,
)
if result.status == ImportStatus.FAILED:
session.rollback()
@@ -252,6 +261,72 @@ def _rewrite(
return output.getvalue()
+def _add_roster_node(session: Session, app: App, *, graph_binding: Mapping[str, object] | None = None) -> Agent:
+ workflow = session.get(Workflow, "workflow-1")
+ assert workflow is not None
+ graph = workflow.graph_dict
+ data: dict[str, object] = {"type": "agent", "version": "2", "title": "Roster", "agent_node_kind": "dify_agent"}
+ if graph_binding is not None:
+ data["agent_binding"] = dict(graph_binding)
+ graph["nodes"].append({"id": "node-3", "data": data})
+ workflow.graph = json.dumps(graph)
+ agent = Agent(
+ id="roster-agent-1",
+ tenant_id=app.tenant_id,
+ name="Roster",
+ scope=AgentScope.ROSTER,
+ source=AgentSource.ROSTER,
+ status=AgentStatus.ACTIVE,
+ active_config_snapshot_id="roster-snapshot-1",
+ created_by="account-1",
+ )
+ snapshot = AgentConfigSnapshot(
+ id="roster-snapshot-1",
+ tenant_id=app.tenant_id,
+ agent_id=agent.id,
+ version=1,
+ config_snapshot=AgentSoulConfig.model_validate({"prompt": {"system_prompt": "Roster"}}),
+ created_by="account-1",
+ )
+ binding = WorkflowAgentNodeBinding(
+ tenant_id=app.tenant_id,
+ app_id=app.id,
+ workflow_id=workflow.id,
+ workflow_version=workflow.version,
+ node_id="node-3",
+ binding_type=WorkflowAgentBindingType.ROSTER_AGENT,
+ agent_id=agent.id,
+ current_snapshot_id=snapshot.id,
+ node_job_config={"workflow_prompt": "Roster job"},
+ created_by="account-1",
+ )
+ session.add_all([agent, snapshot, binding])
+ session.commit()
+ return agent
+
+
+def _read_export(content: bytes) -> tuple[dict[str, object], dict[str, object]]:
+ with zipfile.ZipFile(io.BytesIO(content)) as archive:
+ return yaml.safe_load(archive.read("app.yaml")), yaml.safe_load(archive.read("manifest.yaml"))
+
+
+def _node_data(data: dict[str, object], node_id: str = "node-3") -> dict[str, object]:
+ workflow = cast(dict[str, dict[str, list[dict[str, object]]]], data["workflow"])
+ return next(cast(dict[str, object], node["data"]) for node in workflow["graph"]["nodes"] if node["id"] == node_id)
+
+
+def _roster_export(session: Session, storage: _MemoryStorage) -> bytes:
+ app = _source(session, storage)
+ _add_roster_node(session, app)
+ with AppPackageService().export_app(app_model=app, preserve_agent_bindings=True) as exported:
+ return exported.archive.read()
+
+
+def _bindings_by_node(session: Session, app_id: str | None) -> dict[str, WorkflowAgentNodeBinding]:
+ rows = session.scalars(select(WorkflowAgentNodeBinding).where(WorkflowAgentNodeBinding.app_id == app_id))
+ return {row.node_id: row for row in rows}
+
+
class TestWorkflowPackageServiceCases:
@staticmethod
@pytest.fixture
@@ -547,6 +622,140 @@ class TestWorkflowPackageServiceCases:
assert result.status == ImportStatus.COMPLETED_WITH_WARNINGS, result.error
assert any(warning.code == "agent_file_omitted" for warning in result.warnings)
+ @staticmethod
+ def test_reader_keeps_legacy_packaged_roster_nodes(sqlite_session: Session, storage: _MemoryStorage) -> None:
+ app = _source(sqlite_session, storage)
+ with AppPackageService().export_app(app_model=app) as exported:
+ content = exported.archive.read()
+
+ def mutate(_manifest: AppPackageManifest, data: dict[str, object], _members: dict[str, bytes]) -> None:
+ cast(dict[str, object], _node_data(data, "node-1")["agent_binding"])["binding_type"] = "roster_agent"
+
+ legacy = _rewrite(content, mutate)
+ prepared = AppPackageService().read_package(io.BytesIO(legacy), accept_roster_references=True)
+ assert prepared is not None
+ prepared.close()
+
+ @staticmethod
+ def test_package_export_keeps_roster_references(sqlite_session: Session, storage: _MemoryStorage) -> None:
+ app = _source(sqlite_session, storage)
+ _add_roster_node(sqlite_session, app)
+ with AppPackageService().export_app(app_model=app, preserve_agent_bindings=True) as exported:
+ data, manifest = _read_export(exported.archive.read())
+ node = _node_data(data)
+ assert node["agent_binding"] == {
+ "binding_type": "roster_agent",
+ "agent_id": "roster-agent-1",
+ "current_snapshot_id": "roster-snapshot-1",
+ }
+ assert node["agent_task"] == "Roster job"
+ assert (
+ set(cast(dict[str, object], manifest["agent_resources"]))
+ == set(cast(dict[str, object], data["agent_packages"]))
+ == {"agent_1", "agent_2"}
+ )
+
+ @staticmethod
+ @pytest.mark.usefixtures("storage")
+ def test_roster_only_package_export_passes_self_check(sqlite_session: Session) -> None:
+ app = make_app(mode=AppMode.WORKFLOW, name="Roster Only")
+ workflow = make_workflow(
+ workflow_id="workflow-1",
+ app_id=app.id,
+ graph={"nodes": [], "edges": []},
+ workflow_type=WorkflowType.WORKFLOW,
+ version=Workflow.VERSION_DRAFT,
+ )
+ sqlite_session.add_all([app, workflow])
+ sqlite_session.commit()
+ _add_roster_node(sqlite_session, app)
+ with AppPackageService().export_app(app_model=app, preserve_agent_bindings=True) as exported:
+ data, manifest = _read_export(exported.archive.read())
+ assert not manifest.get("agent_resources")
+ assert cast(dict[str, object], _node_data(data)["agent_binding"])["agent_id"] == "roster-agent-1"
+
+ @staticmethod
+ def test_published_export_projects_the_exported_versions_bindings(
+ sqlite_session: Session, storage: _MemoryStorage
+ ) -> None:
+ app = _source(sqlite_session, storage, published=True)
+ _add_roster_node(sqlite_session, app, graph_binding={"binding_type": "roster_agent", "agent_id": "stale-agent"})
+ with AppPackageService().export_app(
+ app_model=app, workflow_id="workflow-1", preserve_agent_bindings=True
+ ) as exported:
+ content = exported.archive.read()
+ data, _manifest = _read_export(content)
+ node = _node_data(data)
+ assert cast(dict[str, object], node["agent_binding"])["agent_id"] == "roster-agent-1"
+ assert node["agent_task"] == "Roster job"
+ result = _import(sqlite_session, content, account=_account("tenant-1"), preserve_agent_bindings=True)
+ assert result.status == ImportStatus.COMPLETED, result.error
+ roster = sqlite_session.scalars(
+ select(WorkflowAgentNodeBinding).where(
+ WorkflowAgentNodeBinding.app_id == result.app_id,
+ WorkflowAgentNodeBinding.node_id == "node-3",
+ )
+ ).one()
+ assert (roster.binding_type, roster.agent_id) == (WorkflowAgentBindingType.ROSTER_AGENT, "roster-agent-1")
+ assert roster.node_job_config_dict["workflow_prompt"] == "Roster job"
+
+ @staticmethod
+ def test_overwrite_with_mixed_graph_keeps_roster_link(
+ sqlite_session: Session, storage: _MemoryStorage, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ monkeypatch.setattr(
+ "services.app_dsl_service.WorkflowAgentRetirementService.retire_unowned", lambda **_kwargs: None
+ )
+ content = _roster_export(sqlite_session, storage)
+ account = _account("tenant-1")
+ original = _import(sqlite_session, content, account=account, preserve_agent_bindings=True)
+ updated = _import(
+ sqlite_session, content, app_id=original.app_id, account=account, preserve_agent_bindings=True
+ )
+ assert updated.status == ImportStatus.COMPLETED, updated.error
+ rows = _bindings_by_node(sqlite_session, original.app_id)
+ assert rows["node-3"].binding_type == WorkflowAgentBindingType.ROSTER_AGENT
+ assert rows["node-3"].agent_id == "roster-agent-1"
+ assert rows["node-3"].node_job_config_dict["workflow_prompt"] == "Roster job"
+ assert {rows["node-1"].binding_type, rows["node-2"].binding_type} == {WorkflowAgentBindingType.INLINE_AGENT}
+
+ @staticmethod
+ def test_unresolvable_roster_reference_fails_the_import(sqlite_session: Session, storage: _MemoryStorage) -> None:
+ content = _roster_export(sqlite_session, storage)
+
+ def mutate(_manifest: AppPackageManifest, data: dict[str, object], _members: dict[str, bytes]) -> None:
+ cast(dict[str, object], _node_data(data)["agent_binding"])["agent_id"] = "missing-agent"
+
+ result = _import(
+ sqlite_session, _rewrite(content, mutate), account=_account("tenant-1"), preserve_agent_bindings=True
+ )
+ assert result.status == ImportStatus.FAILED
+ assert "roster agent" in (result.error or "")
+
+ @staticmethod
+ def test_confirm_keeps_roster_link(
+ sqlite_session: Session, storage: _MemoryStorage, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ content = _roster_export(sqlite_session, storage)
+
+ def mutate(_manifest: AppPackageManifest, data: dict[str, object], _members: dict[str, bytes]) -> None:
+ data["version"] = "99.0.0"
+
+ pending: dict[str, str] = {}
+ monkeypatch.setattr(
+ "services.app_dsl_service.redis_client.setex", lambda key, _ttl, value: pending.__setitem__(key, value)
+ )
+ monkeypatch.setattr("services.app_dsl_service.redis_client.get", pending.get)
+ monkeypatch.setattr("services.app_dsl_service.redis_client.delete", pending.pop)
+ account = _account("tenant-1")
+ result = _import(sqlite_session, _rewrite(content, mutate), account=account, preserve_agent_bindings=True)
+ assert result.status == ImportStatus.PENDING
+ confirmed = AppDslService(sqlite_session).confirm_import(import_id=result.id, account=account)
+ assert confirmed.status in {ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS}, confirmed.error
+ row = _bindings_by_node(sqlite_session, confirmed.app_id)["node-3"]
+ assert row.binding_type == WorkflowAgentBindingType.ROSTER_AGENT
+ assert row.agent_id == "roster-agent-1"
+
"""Ordinary App packages preserve DSLs and enforce container integrity."""
@@ -573,6 +782,26 @@ def _dsl_with_size(size: int) -> str:
return header + "\U0001f600" * (padding // 4) + "a" * (padding % 4)
+def _roster_archive(binding: dict[str, object], agent_job: dict[str, object] | None = None) -> io.BytesIO:
+ node_data = {
+ "type": "agent",
+ "version": "2",
+ "title": "Roster",
+ "agent_node_kind": "dify_agent",
+ "agent_binding": binding,
+ "agent_job": agent_job or {"workflow_prompt": "Roster job"},
+ }
+ dsl = yaml.safe_dump(
+ {
+ "kind": "app",
+ "app": {"mode": "workflow", "name": "Roster"},
+ "workflow": {"graph": {"nodes": [{"id": "node-1", "data": node_data}], "edges": []}},
+ }
+ )
+ with AppPackageService().export(dsl=dsl, name="Roster") as package:
+ return io.BytesIO(package.archive.read())
+
+
class TestAppPackageServiceCases:
@staticmethod
@pytest.mark.parametrize("mode", ["workflow", "advanced-chat", "chat", "completion", "agent-chat"])
@@ -658,6 +887,39 @@ class TestAppPackageServiceCases:
with pytest.raises(RosterAgentPackageTooLargeError):
AppPackageService().read_package(source)
+ @staticmethod
+ @pytest.mark.parametrize(
+ ("binding", "agent_job"),
+ [
+ pytest.param({"binding_type": "roster_agent"}, None, id="agent-id-missing"),
+ pytest.param({"binding_type": "roster_agent", "agent_id": ""}, None, id="agent-id-empty"),
+ pytest.param(
+ {"binding_type": "roster_agent", "agent_id": "a", "package_ref": "agent_1"},
+ None,
+ id="package-ref-extra",
+ ),
+ pytest.param(
+ {"binding_type": "roster_agent", "agent_id": "a"},
+ {"declared_outputs": "not-a-list"},
+ id="invalid-agent-job",
+ ),
+ ],
+ )
+ def test_roster_only_package_rejects_bad_references_when_accepted(
+ binding: dict[str, object], agent_job: dict[str, object] | None
+ ) -> None:
+ with pytest.raises(InvalidRosterAgentPackageError, match="Agent references are invalid"):
+ AppPackageService().read_package(_roster_archive(binding, agent_job), accept_roster_references=True)
+
+ @staticmethod
+ def test_non_workflow_package_is_accepted_when_roster_references_accepted() -> None:
+ dsl = yaml.safe_dump({"kind": "app", "app": {"mode": "chat", "name": "Chat"}})
+ with AppPackageService().export(dsl=dsl, name="Chat") as package:
+ prepared = AppPackageService().read_package(package.archive, accept_roster_references=True)
+ assert prepared is not None
+ assert prepared.agents == {}
+ prepared.close()
+
"""Packaged image icons travel with Apps and receive destination-owned file ids."""