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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
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.pyindex 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, whileruntime/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.pyindex 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,)@overridediff --git a/api/services/app/console_service.py b/api/services/app/console_service.pyindex 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, Nonediff --git a/api/services/app/import_service.py b/api/services/app/import_service.pyindex 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 = accountsself._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.pyindex 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 = Noneapp_id: str | None = Nonedraft_hash: str | None = None+ preserve_agent_bindings: bool = Falsewarnings: 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.pyindex f1818408beb..b4e7e8a219c 100644--- a/api/services/app_package_service.py+++ b/api/services/app_package_service.py@@ -7,7 +7,7 @@ import reimport tempfileimport zipfileimport zlib-from collections.abc import Iterator+from collections.abc import Iterator, Mappingfrom dataclasses import dataclass, fieldfrom typing import Any, BinaryIO, Literal, Self, cast@@ -18,8 +18,8 @@ from core.db.session_factory import session_factoryfrom core.workflow.nodes.agent_v2.validators import WorkflowAgentNodeValidatorfrom models.agent import WorkflowAgentBindingTypefrom 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, AgentPackagefrom services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeErrorfrom services.agent.package_resource_exporter import AgentPackageResourceExporterfrom services.agent.package_resource_importer import AgentPackageResourceImporter@@ -39,6 +39,8 @@ from services.dsl_content import DSL_MAX_SIZEfrom services.entities.dsl_entities import DslImportWarningfrom 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: SIM115try:@@ -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.pyindex 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_dslif 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 eventsreturnif entry == "confirm":returned, was_created = gateway.confirm_import(context, "import")assert was_created is createdelse:- returned = gateway.import_dsl(context, AppImportParams(mode="yaml-content"), as_copy=entry == "copy")+ returned = import_entry(context, AppImportParams(mode="yaml-content"))assert returned is resultexpected = 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 Truediff --git a/api/tests/unit_tests/services/app/test_console_service.py b/api/tests/unit_tests/services/app/test_console_service.pyindex 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_copyreturn 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.pyindex 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 annotationsimport hashlibimport io+import jsonimport zipfile-from collections.abc import Callable, Generator+from collections.abc import Callable, Generator, Mappingfrom types import SimpleNamespacefrom typing import castfrom 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 Nonewith prepared:result = AppDslService(session).import_app(@@ -225,6 +233,7 @@ def _import(session: Session, content: bytes, *, app_id: str | None = None, accoyaml_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.errorassert 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."""