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(app): package inline agents in workflow and chatflow exports (#42579)
林玮 (Jade Lin)e78ce4db64ab
diff --git a/api/controllers/console/app/app.py b/api/controllers/console/app/app.pyindex 676bb426226..63433f38a93 100644--- a/api/controllers/console/app/app.py+++ b/api/controllers/console/app/app.py@@ -1086,14 +1086,10 @@ class AppExportApi(Resource):tenant_id=app_model.tenant_id, agent_id=agent_id, version_id=req_data.version_id)else:- exported = AppPackageService().export(- dsl=AppDslService.export_dsl(- app_model=app_model,- session=db.session(),- include_secret=req_data.include_secret,- workflow_id=req_data.workflow_id,- ),- name=app_model.name,+ exported = AppPackageService().export_app(+ app_model=app_model,+ include_secret=req_data.include_secret,+ workflow_id=req_data.workflow_id,)try:archive_response = send_file(diff --git a/api/controllers/console/app/app_import.py b/api/controllers/console/app/app_import.pyindex b0b98dff464..0ba35c9cffb 100644--- a/api/controllers/console/app/app_import.py+++ b/api/controllers/console/app/app_import.py@@ -37,7 +37,7 @@ from services.app_dsl_service import (PendingData,)from services.app_import_source import download_app_import_source, try_read_yaml-from services.app_package_service import AppPackageService+from services.app_package_service import AppPackageService, PreparedAppPackagefrom services.enterprise.enterprise_service import EnterpriseServicefrom services.entities.dsl_entities import CheckDependenciesResult, ImportStatusfrom services.errors.account import NoPermissionError@@ -165,14 +165,16 @@ class AppImportApi(Resource):if not uploaded.filename.lower().endswith(".ifpkg"):raise InvalidRosterAgentPackageError("App package file must use the .ifpkg extension")source = cast(BinaryIO, uploaded.stream)- dsl = AppPackageService().read_dsl(source)- if dsl is not None:- if payload is None:- payload = AppImportPayload.model_validate({**request.form.to_dict(), "mode": "yaml-content"})- return self._import_dsl(- payload.model_copy(update={"mode": "yaml-content", "yaml_content": dsl, "yaml_url": None}),- current_user,- )+ package = AppPackageService().read_package(source)+ if package is not None:+ with package:+ if payload is None:+ payload = AppImportPayload.model_validate({**request.form.to_dict(), "mode": "yaml-content"})+ return self._import_dsl(+ payload.model_copy(update={"mode": "yaml-content", "yaml_content": package.dsl, "yaml_url": None}),+ current_user,+ package=package,+ )return self._import_agent_package(current_user, source, payload)@rbac_permission_required(RBACCheck(RBACPermission.AGENT_CREATE, Workspace()))@@ -196,7 +198,13 @@ class AppImportApi(Resource):@cloud_edition_billing_resource_check("apps")@rbac_permission_required(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace()))- def _import_dsl(self, req_data: AppImportPayload, current_user: Account | None = None):+ def _import_dsl(+ self,+ req_data: AppImportPayload,+ current_user: Account | None = None,+ *,+ package: PreparedAppPackage | None = None,+ ):current_user = current_user if current_user is not None else _current_user_and_tenant_id(None)[0]# AppDslService performs internal commits for some creation paths, so use a plain@@ -217,6 +225,7 @@ class AppImportApi(Resource):icon=req_data.icon,icon_background=req_data.icon_background,app_id=req_data.app_id,+ package=package,)except NoPermissionError as e:raise Forbidden(str(e))diff --git a/api/services/agent/dsl_service.py b/api/services/agent/dsl_service.pyindex 722db771a7a..d5d31d63467 100644--- a/api/services/agent/dsl_service.py+++ b/api/services/agent/dsl_service.py@@ -15,11 +15,12 @@ from typing import Any, castfrom uuid import UUIDfrom pydantic import BaseModel, ConfigDict, Field-from sqlalchemy import func, select+from sqlalchemy import func, select, updatefrom sqlalchemy.orm import Sessionfrom core.workflow.nodes.agent_v2.discriminator import is_dify_agent_node_datafrom core.workflow.nodes.agent_v2.validators import WorkflowAgentNodeValidator+from libs.datetime_utils import naive_utc_nowfrom models import Accountfrom models.agent import (APP_BACKED_AGENT_SOURCES,@@ -38,7 +39,7 @@ from models.agent import (WorkflowAgentNodeBinding,)from models.agent_config_entities import AgentSoulConfig, WorkflowNodeJobConfig-from models.model import App, AppModelConfig+from models.model import App, AppModelConfig, UploadFilefrom models.skill import AgentSkillBinding, AgentSkillBindingSnapshot, Skillfrom models.workflow import Workflowfrom services.agent.agent_soul_state import agent_soul_has_model@@ -53,6 +54,7 @@ from services.agent.dsl_entities import (portable_ref,)from services.agent.knowledge_datasets import get_tenant_knowledge_dataset_rows+from services.agent.package_resource_exporter import AgentPackageResourceExporterfrom services.agent.roster_service import AgentRosterServicefrom services.entities.dsl_entities import DslImportWarning@@ -129,9 +131,13 @@ class AgentDslService:return package_ref, {package_ref: make_portable_agent_package(agent, soul, workspace_skills=workspace_skills)}def export_workflow_packages(- self, *, workflow: Workflow, graph: Mapping[str, Any]+ self,+ *,+ workflow: Workflow,+ graph: Mapping[str, Any],+ resource_exporter: AgentPackageResourceExporter | None = None,) -> tuple[dict[str, Any], dict[str, AgentPackage]]:- """Replace persisted Agent binding ids with portable package references."""+ """Replace persisted bindings with portable packages, optionally collecting their assets."""portable_graph = copy.deepcopy(dict(graph))agent_nodes = dict(WorkflowAgentNodeValidator.iter_agent_v2_nodes(portable_graph))@@ -141,6 +147,7 @@ class AgentDslService:bindings = self.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,WorkflowAgentNodeBinding.node_id.in_(list(agent_nodes)),@@ -166,16 +173,25 @@ class AgentDslService:if package_ref is None:package_ref = f"agent_{len(packages) + 1}"package_refs_by_source[source_key] = package_ref- packages[package_ref] = make_portable_agent_package(- agent,- AgentSoulConfig.model_validate(snapshot.config_snapshot_dict),- workspace_skills=self._workspace_skills_for_export(- tenant_id=workflow.tenant_id,- agent_id=agent.id,+ if resource_exporter is not None:+ packages[package_ref] = resource_exporter.collect_package(+ session=self.session,+ agent=agent,+ soul=AgentSoulConfig.model_validate(snapshot.config_snapshot_dict),snapshot_id=snapshot.id,- include_draft=False,- ),- )+ package_ref=package_ref,+ )+ else:+ packages[package_ref] = make_portable_agent_package(+ agent,+ AgentSoulConfig.model_validate(snapshot.config_snapshot_dict),+ workspace_skills=self._workspace_skills_for_export(+ tenant_id=workflow.tenant_id,+ agent_id=agent.id,+ snapshot_id=snapshot.id,+ include_draft=False,+ ),+ )node_data["agent_binding"] = {"binding_type": binding.binding_type.value,AGENT_PACKAGE_REF_KEY: package_ref,@@ -515,6 +531,15 @@ class AgentDslService:warnings=warnings,account_id=account.id,)+ upload_file_ids = [+ item.file_id for item in soul.config_files if item.file_kind == "upload_file" and not item.is_missing+ ]+ if upload_file_ids:+ self.session.execute(+ update(UploadFile)+ .where(UploadFile.tenant_id == workflow.tenant_id, UploadFile.id.in_(upload_file_ids))+ .values(used=True, used_by=account.id, used_at=naive_utc_now())+ )return AgentPackageImportResult(agent=agent, snapshot=snapshot, warnings=warnings)def _create_workflow_only_agent(diff --git a/api/services/agent/package_resource_exporter.py b/api/services/agent/package_resource_exporter.pynew file mode 100644index 00000000000..2f16238c939--- /dev/null+++ b/api/services/agent/package_resource_exporter.py@@ -0,0 +1,317 @@+"""Collect and stream Agent assets for roster and workflow package exports."""++from __future__ import annotations++import hashlib+import os+import re+import zipfile+from collections.abc import Generator, Sequence+from dataclasses import dataclass+from typing import Literal, Protocol++from sqlalchemy import select+from sqlalchemy.orm import Session++from configs import dify_config+from extensions.ext_storage import storage+from models.agent import Agent+from models.agent_config_entities import AgentSoulConfig+from models.model import UploadFile+from models.tools import ToolFile+from services.agent.dsl_entities import AgentPackage, AgentPackageWorkspaceSkill, make_portable_agent_package+from services.agent.errors import RosterAgentPackageExportFailedError, RosterAgentPackageTooLargeError+from services.agent.roster_package_entities import (+ AgentPackageResources,+ RosterAgentPackageAudit,+ RosterAgentPackageFile,+ RosterAgentPackageSkill,+)+from services.agent.skill_package_service import SkillPackageError, SkillPackageService+from services.skill_management_service import SkillManagementService+++class _Storage(Protocol):+ def load_stream(self, filename: str) -> Generator[bytes, None, None]: ...+++@dataclass(frozen=True)+class _SkillSource:+ path: str+ storage_key: str+ id: str+ scope: Literal["agent_config", "workspace"]+ name: str+ audit_ref: str+++@dataclass(frozen=True)+class _FileSource:+ path: str+ storage_key: str+ id: str+ audit_ref: str+++class AgentPackageResourceExporter:+ """Collect database references, resolve workspace Skills, then stream the archive."""++ def __init__(self, *, storage_backend: _Storage = storage) -> None:+ self._storage = storage_backend+ self.sources: dict[str, tuple[list[_SkillSource], list[_FileSource]]] = {}+ self.packages: dict[str, AgentPackage] = {}+ self._workspace_sources: dict[str, tuple[str, str, str | None, bool]] = {}++ def collect_package(+ self,+ *,+ session: Session,+ agent: Agent,+ soul: AgentSoulConfig,+ snapshot_id: str | None,+ package_ref: str,+ include_draft: bool = False,+ ) -> AgentPackage:+ soul, skills, files = self._collect_payloads(+ session=session,+ tenant_id=agent.tenant_id,+ soul=soul,+ skill_offset=sum(len(skills) for skills, _ in self.sources.values()),+ file_offset=sum(len(files) for _, files in self.sources.values()),+ )+ self.sources[package_ref] = skills, files+ package = make_portable_agent_package(agent, soul, include_assets=True)+ self.packages[package_ref] = package+ self._workspace_sources[package_ref] = agent.tenant_id, agent.id, snapshot_id, include_draft+ return package++ def collect_workspace_skills(self) -> None:+ """Resolve legacy Skill metadata after the caller closes its database read session."""+ for ref, (tenant_id, agent_id, snapshot_id, include_draft) in self._workspace_sources.items():+ package = self.packages[ref]+ archives = SkillManagementService().list_runtime_agent_skill_archives(+ tenant_id=tenant_id,+ agent_id=agent_id,+ config_snapshot_id=snapshot_id,+ include_draft=include_draft,+ )+ skill_sources = self.sources[ref][0]+ skill_index = sum(len(skills) for skills, _ in self.sources.values())+ names = {item.name for item in package.soul.config_skills if not item.is_missing}+ for archive in sorted(archives, key=lambda item: item.priority):+ if archive.name in names:+ continue+ names.add(archive.name)+ skill_index += 1+ resource_id = f"s_{skill_index:06d}"+ skill_sources.append(+ _SkillSource(+ path=f"{resource_id}.zip",+ storage_key=archive.storage_key,+ id=resource_id,+ scope="workspace",+ name=archive.name,+ audit_ref=archive.version_id,+ )+ )+ package.workspace_skills.append(+ AgentPackageWorkspaceSkill(+ name=archive.name,+ display_name=archive.display_name,+ description=archive.description,+ priority=archive.priority,+ )+ )+ self._workspace_sources.clear()++ def write_resources(self, archive: zipfile.ZipFile) -> tuple[dict[str, AgentPackageResources], int]:+ entry_count = sum(len(skills) + len(files) for skills, files in self.sources.values()) + 2+ if entry_count > dify_config.AGENT_PACKAGE_MAX_ENTRIES:+ raise RosterAgentPackageTooLargeError("Agent package has too many members")+ total_size = 0+ nested_uncompressed_size = 0+ skill_packages = SkillPackageService()+ resources: dict[str, AgentPackageResources] = {}+ for ref, (skill_sources, file_sources) in self.sources.items():+ skills: list[RosterAgentPackageSkill] = []+ files: list[RosterAgentPackageFile] = []+ sources: list[_SkillSource | _FileSource] = [*skill_sources, *file_sources]+ for source in sources:+ remaining_bytes = dify_config.AGENT_PACKAGE_MAX_BYTES - total_size+ if isinstance(source, _SkillSource):+ remaining_bytes = min(remaining_bytes, dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024)+ member_size, member_digest = self._write_storage_member(+ archive, path=source.path, storage_key=source.storage_key, max_bytes=remaining_bytes+ )+ total_size += member_size+ if isinstance(source, _SkillSource):+ # Inspect only the embedded Skill; our writer already owns+ # the outer container, resource sizes, and digests.+ try:+ inspection = skill_packages.inspect(content=archive.read(source.path), filename=source.path)+ except SkillPackageError as exc:+ raise RosterAgentPackageExportFailedError(+ f"Roster Agent package contains unusable Skill {source.name!r}"+ ) from exc+ if inspection.name != source.name:+ raise RosterAgentPackageExportFailedError(+ f"Roster Agent package contains unusable Skill {source.name!r}: name mismatch"+ )+ nested_uncompressed_size += inspection.uncompressed_size+ if nested_uncompressed_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError(+ "Roster Agent package nested Skill contents exceed the size limit"+ )++ skills.append(+ RosterAgentPackageSkill(+ id=source.id,+ scope=source.scope,+ name=source.name,+ path=source.path,+ size=member_size,+ sha256=member_digest,+ audit=RosterAgentPackageAudit(ref=source.audit_ref),+ )+ )+ else:+ files.append(+ RosterAgentPackageFile(+ id=source.id,+ path=source.path,+ size=member_size,+ sha256=member_digest,+ audit=RosterAgentPackageAudit(ref=source.audit_ref),+ )+ )+ resources[ref] = AgentPackageResources(skills=skills, files=files)+ return resources, total_size++ def _collect_payloads(+ self,+ *,+ session: Session,+ tenant_id: str,+ soul: AgentSoulConfig,+ skill_offset: int = 0,+ file_offset: int = 0,+ ) -> tuple[AgentSoulConfig, list[_SkillSource], list[_FileSource]]:+ resource_data = soul.model_dump(mode="json")+ skill_sources: list[_SkillSource] = []+ file_sources: list[_FileSource] = []++ skill_file_ids = [item.file_id for item in soul.config_skills if not item.is_missing]+ tool_files = self._tool_files(session=session, tenant_id=tenant_id, file_ids=skill_file_ids)+ for skill_ref, portable_skill_ref in zip(soul.config_skills, resource_data["config_skills"]):+ if skill_ref.is_missing:+ continue+ resource_id = f"s_{skill_offset + len(skill_sources) + 1:06d}"+ tool_file = tool_files.get(skill_ref.file_id)+ if tool_file is None:+ raise RosterAgentPackageExportFailedError(f"Config skill {skill_ref.name!r} payload is unavailable")+ path = f"{resource_id}.zip"+ portable_skill_ref["file_id"] = resource_id+ portable_skill_ref["is_missing"] = False+ skill_sources.append(+ _SkillSource(+ path=path,+ storage_key=tool_file.file_key,+ id=resource_id,+ scope="agent_config",+ name=skill_ref.name,+ audit_ref=tool_file.id,+ )+ )++ tool_file_refs = [+ item.file_id for item in soul.config_files if not item.is_missing and item.file_kind == "tool_file"+ ]+ upload_file_refs = [+ item.file_id for item in soul.config_files if not item.is_missing and item.file_kind == "upload_file"+ ]+ file_tool_files = self._tool_files(session=session, tenant_id=tenant_id, file_ids=tool_file_refs)+ upload_files = self._upload_files(session=session, tenant_id=tenant_id, file_ids=upload_file_refs)+ for file_ref, portable_file_ref in zip(soul.config_files, resource_data["config_files"]):+ if file_ref.is_missing:+ continue+ resource_id = f"f_{file_offset + len(file_sources) + 1:06d}"+ extension = self._safe_extension(file_ref.name)+ path = f"{resource_id}{extension}"+ if file_ref.file_kind == "tool_file":+ tool_file = file_tool_files.get(file_ref.file_id)+ if tool_file is None:+ raise RosterAgentPackageExportFailedError(f"Config file {file_ref.name!r} payload is unavailable")+ storage_key = tool_file.file_key+ mime_type = file_ref.mime_type or tool_file.mimetype+ audit_ref = tool_file.id+ else:+ upload_file = upload_files.get(file_ref.file_id)+ if upload_file is None:+ raise RosterAgentPackageExportFailedError(f"Config file {file_ref.name!r} payload is unavailable")+ storage_key = upload_file.key+ mime_type = file_ref.mime_type or upload_file.mime_type+ audit_ref = upload_file.id+ portable_file_ref["file_id"] = resource_id+ portable_file_ref["is_missing"] = False+ portable_file_ref["mime_type"] = mime_type or "application/octet-stream"+ file_sources.append(+ _FileSource(+ path=path,+ storage_key=storage_key,+ id=resource_id,+ audit_ref=audit_ref,+ )+ )++ return AgentSoulConfig.model_validate(resource_data), skill_sources, file_sources++ @staticmethod+ def _tool_files(*, session: Session, tenant_id: str, file_ids: Sequence[str]) -> dict[str, ToolFile]:+ if not file_ids:+ return {}+ rows = session.scalars(+ select(ToolFile).where(ToolFile.tenant_id == tenant_id, ToolFile.id.in_(set(file_ids)))+ ).all()+ return {item.id: item for item in rows}++ @staticmethod+ def _upload_files(*, session: Session, tenant_id: str, file_ids: Sequence[str]) -> dict[str, UploadFile]:+ if not file_ids:+ return {}+ rows = session.scalars(+ select(UploadFile).where(UploadFile.tenant_id == tenant_id, UploadFile.id.in_(set(file_ids)))+ ).all()+ return {item.id: item for item in rows}++ def _write_storage_member(+ self,+ archive: zipfile.ZipFile,+ *,+ path: str,+ storage_key: str,+ max_bytes: int,+ ) -> tuple[int, str]:+ digest = hashlib.sha256()+ size = 0+ try:+ with archive.open(path, "w", force_zip64=True) as target:+ for chunk in self._storage.load_stream(storage_key):+ if not isinstance(chunk, bytes):+ raise TypeError("storage stream returned a non-bytes chunk")+ if size + len(chunk) > max_bytes:+ raise RosterAgentPackageTooLargeError("Roster Agent package payload exceeds the size limit")+ size += len(chunk)+ digest.update(chunk)+ target.write(chunk)+ except RosterAgentPackageTooLargeError:+ raise+ except Exception as exc:+ raise RosterAgentPackageExportFailedError(f"Unable to read package resource {path!r}") from exc+ return size, digest.hexdigest()++ @staticmethod+ def _safe_extension(filename: str) -> str:+ extension = os.path.splitext(filename)[1].lower()+ if not extension or not re.fullmatch(r"\.[a-z0-9]{1,16}", extension):+ return ".bin"+ return extensiondiff --git a/api/services/agent/package_resource_importer.py b/api/services/agent/package_resource_importer.pynew file mode 100644index 00000000000..372f4e7e6a9--- /dev/null+++ b/api/services/agent/package_resource_importer.py@@ -0,0 +1,232 @@+"""Restore packaged Agent assets before persisting their owning application."""++from __future__ import annotations++import hashlib+import os+from typing import Protocol+from uuid import uuid4++from configs import dify_config+from core.db.session_factory import session_factory+from extensions.ext_storage import storage+from extensions.storage.storage_type import StorageType+from libs.datetime_utils import naive_utc_now+from models.agent_config_entities import AgentSoulConfig+from models.enums import CreatorUserRole+from models.model import UploadFile+from models.tools import ToolFile+from services.agent.composer_validator import ComposerConfigValidator+from services.agent.dsl_entities import AgentPackage, make_portable_agent_soul+from services.agent.errors import (+ InvalidComposerConfigError,+ InvalidRosterAgentPackageError,+ PlaintextSecretNotAllowedError,+ RosterAgentPackageResourceUnavailableError,+)+from services.agent.roster_package_entities import AgentPackageResources, PreparedPackageArchive+from services.agent.roster_package_reader import RosterAgentPackageReader+from services.agent.skill_package_service import SkillPackageError, SkillPackageService+from services.entities.dsl_entities import DslImportWarning+from services.file_service import FileService+++class _Storage(Protocol):+ def save(self, filename: str, data: bytes) -> None: ...+++class AgentPackageResourceImporter:+ def __init__(self, *, storage_backend: _Storage = storage) -> None:+ self._reader = RosterAgentPackageReader()+ self._skill_packages = SkillPackageService()+ self._storage = storage_backend++ def validate(self, *, resources: AgentPackageResources, agent_package: AgentPackage) -> None:+ agent_package.soul = make_portable_agent_soul(agent_package.soul)+ self._validate_supported_resources(resources, soul=agent_package.soul)+ try:+ ComposerConfigValidator.validate_importable_agent_soul(agent_package.soul)+ except (InvalidComposerConfigError, PlaintextSecretNotAllowedError) as exc:+ raise InvalidRosterAgentPackageError("Agent package Soul is invalid") from exc++ @classmethod+ def _validate_supported_resources(cls, resources: AgentPackageResources, *, soul: AgentSoulConfig) -> None:+ skill_names = [item.name for item in soul.config_skills]+ skill_names.extend(item.name for item in resources.skills if item.scope == "workspace")+ if len(skill_names) != len(set(skill_names)):+ raise InvalidRosterAgentPackageError("Roster Agent package contains duplicate effective Skill names")+ file_names = [item.name for item in soul.config_files]+ if len(file_names) != len(set(file_names)):+ raise InvalidRosterAgentPackageError("Roster Agent package contains duplicate config file names")+ file_refs = {item.file_id: item for item in soul.config_files if not item.is_missing}+ for resource in resources.files:+ filename = file_refs[resource.id].name+ extension = cls._extension(filename)+ limit = FileService.file_size_limit(extension=extension)+ if resource.size > limit:+ raise InvalidRosterAgentPackageError(+ f"Roster Agent package file {filename!r} exceeds its file size limit"+ )+ if extension and extension in dify_config.UPLOAD_FILE_EXTENSION_BLACKLIST:+ raise InvalidRosterAgentPackageError(+ f"Roster Agent package file extension '.{extension}' is not allowed"+ )++ def materialize(+ self,+ *,+ archive: PreparedPackageArchive,+ resources: AgentPackageResources,+ agent_package: AgentPackage,+ tenant_id: str,+ account_id: str,+ ) -> tuple[AgentPackage, list[DslImportWarning]]:+ """Upload outside database transactions, then commit all file records together."""+ files: list[ToolFile | UploadFile] = []+ warnings: list[DslImportWarning] = []+ soul_data = agent_package.soul.model_dump(mode="json")+ skill_refs_by_package_id = {+ item["file_id"]: item for item in soul_data["config_skills"] if not item["is_missing"]+ }+ file_refs_by_package_id = {+ item["file_id"]: item for item in soul_data["config_files"] if not item["is_missing"]+ }++ skill_descriptions = {item.name: item.description for item in agent_package.workspace_skills}+ skill_descriptions.update({item.name: item.description for item in agent_package.soul.config_skills})+ for skill_resource in resources.skills:+ target_ref = skill_refs_by_package_id.get(skill_resource.id)+ if target_ref is None:+ target_ref = {}+ soul_data["config_skills"].append(target_ref)+ target_ref.update(+ {+ "name": skill_resource.name,+ "description": skill_descriptions.get(skill_resource.name, ""),+ "file_kind": "tool_file",+ "file_id": "",+ "is_missing": True,+ "size": skill_resource.size,+ "hash": skill_resource.sha256,+ "mime_type": "application/zip",+ }+ )+ reason = archive.invalid_skills.get(skill_resource.id)+ normalized = None+ try:+ if reason is None:+ payload = self._reader.read_member_bytes(+ archive,+ skill_resource.path,+ max_bytes=dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024,+ )+ normalized = self._skill_packages.validate_and_normalize(+ content=payload, filename=skill_resource.path+ )+ except SkillPackageError as exc:+ reason = exc.code+ except InvalidRosterAgentPackageError:+ reason = "archive_integrity_failed"+ if normalized is None:+ warnings.append(+ DslImportWarning(+ code="agent_skill_missing",+ path=f"skills.{skill_resource.id}",+ message=f"Skill {skill_resource.name!r} is damaged and must be uploaded again.",+ details={"name": skill_resource.name, "reason": reason, "path": skill_resource.path},+ )+ )+ continue+ storage_key = f"tools/{tenant_id}/{uuid4().hex}.zip"+ tool_file = ToolFile(+ user_id=account_id,+ tenant_id=tenant_id,+ conversation_id=None,+ file_key=storage_key,+ mimetype="application/zip",+ name=f"{skill_resource.name}.zip",+ size=len(normalized.archive_bytes),+ original_url=None,+ )+ self._save_resource(storage_key=storage_key, payload=normalized.archive_bytes, files=files, row=tool_file)+ target_ref.update(+ {+ "description": normalized.manifest.description,+ "file_id": tool_file.id,+ "is_missing": False,+ "size": tool_file.size,+ "hash": normalized.manifest.hash,+ }+ )++ for file_resource in resources.files:+ package_ref = file_refs_by_package_id[file_resource.id]+ file_kind = package_ref["file_kind"]+ mime_type = package_ref["mime_type"] or "application/octet-stream"+ extension = self._extension(package_ref["name"])+ payload = self._reader.read_member_bytes(archive, file_resource.path, max_bytes=file_resource.size)+ if file_kind == "tool_file":+ storage_key = f"tools/{tenant_id}/{uuid4().hex}.{extension or 'bin'}"+ row: ToolFile | UploadFile = ToolFile(+ user_id=account_id,+ tenant_id=tenant_id,+ conversation_id=None,+ file_key=storage_key,+ mimetype=mime_type,+ name=package_ref["name"],+ size=len(payload),+ original_url=None,+ )+ hash_value = None+ else:+ storage_key = f"upload_files/{tenant_id}/{uuid4()}.{extension or 'bin'}"+ now = naive_utc_now()+ row = UploadFile(+ tenant_id=tenant_id,+ storage_type=StorageType(dify_config.STORAGE_TYPE),+ key=storage_key,+ name=package_ref["name"],+ size=len(payload),+ extension=extension,+ mime_type=mime_type,+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=account_id,+ created_at=now,+ used=False,+ hash=hashlib.sha3_256(payload).hexdigest(),+ )+ hash_value = row.hash+ self._save_resource(storage_key=storage_key, payload=payload, files=files, row=row)+ package_ref.update(+ {+ "file_id": row.id,+ "is_missing": False,+ "size": row.size,+ "hash": hash_value,+ "mime_type": mime_type,+ }+ )++ soul = AgentSoulConfig.model_validate(soul_data)+ with session_factory.create_session() as session, session.begin():+ session.add_all(files)+ # Localized Skills must not bind to same-named Skills in the target workspace.+ return agent_package.model_copy(update={"soul": soul, "workspace_skills": []}), warnings++ def _save_resource(+ self,+ *,+ storage_key: str,+ payload: bytes,+ files: list[ToolFile | UploadFile],+ row: ToolFile | UploadFile,+ ) -> None:+ try:+ self._storage.save(storage_key, payload)+ except Exception as exc:+ raise RosterAgentPackageResourceUnavailableError() from exc+ files.append(row)++ @staticmethod+ def _extension(filename: str) -> str:+ return os.path.splitext(filename)[1].lstrip(".").lower()diff --git a/api/services/agent/roster_package_entities.py b/api/services/agent/roster_package_entities.pyindex 232a08e9675..d9c6515009c 100644--- a/api/services/agent/roster_package_entities.py+++ b/api/services/agent/roster_package_entities.py@@ -3,13 +3,13 @@from __future__ import annotationsimport re-from collections.abc import Mapping+from collections.abc import Iterable, Mappingfrom dataclasses import dataclass, fieldfrom typing import BinaryIO, Final, Literal, Selffrom pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator-from services.agent.dsl_entities import AgentAppDsl+from services.agent.dsl_entities import AgentAppDsl, AgentPackageROSTER_AGENT_PACKAGE_FORMAT: Final[Literal["dify.roster-agent"]] = "dify.roster-agent"ROSTER_AGENT_PACKAGE_FORMAT_VERSION: Final[Literal[1]] = 1@@ -81,15 +81,11 @@ class RosterAgentPackageFile(_RosterAgentPackageResource):return self-class RosterAgentPackageManifest(BaseModel):- """Package metadata and resource index stored in ``manifest.yaml``."""+class AgentPackageResources(BaseModel):+ """Resources belonging to one portable Agent, independent of its container."""model_config = ConfigDict(extra="forbid")- format: Literal["dify.roster-agent"]- format_version: Literal[1]- audit: RosterAgentPackageAudit | None = None- apps: list[RosterAgentPackageApp] = Field(min_length=1)skills: list[RosterAgentPackageSkill] = Field(default_factory=list)files: list[RosterAgentPackageFile] = Field(default_factory=list)@@ -98,7 +94,7 @@ class RosterAgentPackageManifest(BaseModel):ids = [item.id for item in self.skills] + [item.id for item in self.files]if len(ids) != len(set(ids)):raise ValueError("resource ids must be unique")- paths = [item.path.casefold() for item in [*self.apps, *self.skills, *self.files]]+ paths = [item.path.casefold() for item in [*self.skills, *self.files]]if len(paths) != len(set(paths)):raise ValueError("resource paths must be unique")skill_names = [item.name for item in self.skills]@@ -107,20 +103,23 @@ class RosterAgentPackageManifest(BaseModel):return self- def validate_apps(self, apps: Mapping[str, AgentAppDsl]) -> None:- """Resolve all application references against the shared resource index."""- if set(apps) != {item.path for item in self.apps}:- raise ValueError("app members must match the package app index")+ def validate_packages(self, packages: Iterable[AgentPackage]) -> None:+ """Resolve Agent references against this resource index."""skill_by_id = {item.id: item for item in self.skills}file_by_id = {item.id: item for item in self.files}workspace_names = {item.name for item in self.skills if item.scope == "workspace"}referenced_skill_ids: set[str] = set()referenced_file_ids: set[str] = set()referenced_workspace_names: set[str] = set()- for app in apps.values():- if app.package.soul.schema_version != 1:+ for package in packages:+ if package.soul.schema_version != 1:raise ValueError("unsupported Agent Soul schema version")- for skill_ref in app.package.soul.config_skills:+ resource_ids = [item.file_id for item in package.soul.config_skills if not item.is_missing] + [+ item.file_id for item in package.soul.config_files if not item.is_missing+ ]+ if len(resource_ids) != len(set(resource_ids)):+ raise ValueError("Agent config resources must have unique references")+ for skill_ref in package.soul.config_skills:if skill_ref.is_missing:continueskill_resource = skill_by_id.get(skill_ref.file_id)@@ -129,13 +128,13 @@ class RosterAgentPackageManifest(BaseModel):if skill_resource.name != skill_ref.name:raise ValueError("config skill name must match its resource metadata")referenced_skill_ids.add(skill_resource.id)- app_workspace_names = [item.name for item in app.package.workspace_skills]+ app_workspace_names = [item.name for item in package.workspace_skills]if len(app_workspace_names) != len(set(app_workspace_names)):raise ValueError("workspace skill names must be unique in the Agent DSL")if set(app_workspace_names) - workspace_names:raise ValueError("workspace skill references must match the package resource index")referenced_workspace_names.update(app_workspace_names)- for file_ref in app.package.soul.config_files:+ for file_ref in package.soul.config_files:if file_ref.is_missing:continueif file_ref.file_id not in file_by_id:@@ -149,26 +148,51 @@ class RosterAgentPackageManifest(BaseModel):raise ValueError("file resources must be referenced by the Agent Soul")-@dataclass-class PreparedRosterAgentPackage:- """Validated archive retained in a bounded spool for later materialization."""+class RosterAgentPackageManifest(AgentPackageResources):+ """Package metadata and resource index stored in ``manifest.yaml``."""++ format: Literal["dify.roster-agent"]+ format_version: Literal[1]+ audit: RosterAgentPackageAudit | None = None+ apps: list[RosterAgentPackageApp] = Field(min_length=1)++ @model_validator(mode="after")+ def validate_app_paths(self) -> Self:+ paths = [item.path.casefold() for item in [*self.apps, *self.skills, *self.files]]+ if len(paths) != len(set(paths)):+ raise ValueError("resource paths must be unique")+ return self++ def validate_apps(self, apps: Mapping[str, AgentAppDsl]) -> None:+ if set(apps) != {item.path for item in self.apps}:+ raise ValueError("app members must match the package app index")+ self.validate_packages(app.package for app in apps.values())+++@dataclass(kw_only=True)+class PreparedPackageArchive:+ """Own one validated archive and its member index until import finishes."""archive: BinaryIO- manifest: RosterAgentPackageManifest- apps: dict[str, AgentAppDsl]members: dict[str, RosterAgentPackageMember]invalid_skills: dict[str, str] = field(default_factory=dict)def close(self) -> None:self.archive.close()- def __enter__(self) -> PreparedRosterAgentPackage:+ def __enter__(self) -> Self:return selfdef __exit__(self, *_args: object) -> None:self.close()+@dataclass(kw_only=True)+class PreparedRosterAgentPackage(PreparedPackageArchive):+ manifest: RosterAgentPackageManifest+ apps: dict[str, AgentAppDsl]++@dataclassclass RosterAgentPackageExport:"""Download artifact owning its archive until the response closes."""@@ -191,6 +215,8 @@ __all__ = ["ROSTER_AGENT_PACKAGE_FORMAT","ROSTER_AGENT_PACKAGE_FORMAT_VERSION","ROSTER_AGENT_PACKAGE_MAX_SIGNATURE_BYTES",+ "AgentPackageResources",+ "PreparedPackageArchive","PreparedRosterAgentPackage","RosterAgentPackageApp","RosterAgentPackageAudit",diff --git a/api/services/agent/roster_package_exporter.py b/api/services/agent/roster_package_exporter.pyindex de9d4331213..bc41a4ac798 100644--- a/api/services/agent/roster_package_exporter.py+++ b/api/services/agent/roster_package_exporter.py@@ -3,18 +3,15 @@from __future__ import annotationsimport hashlib-import osimport reimport tempfileimport zipfile-from collections.abc import Callable, Generator, Sequence-from dataclasses import dataclass-from typing import BinaryIO, Literal, Protocol, cast+from collections.abc import Callable+from typing import BinaryIO, castfrom uuid import UUIDimport yamlfrom sqlalchemy import or_, select-from sqlalchemy.orm import Sessionfrom configs import dify_configfrom core.db.session_factory import session_factory@@ -31,60 +28,28 @@ from models.agent import ()from models.agent_config_entities import AgentSoulConfigfrom models.enums import AppStatus-from models.model import App, AppMode, UploadFile-from models.tools import ToolFile+from models.model import App, AppModefrom services.agent.dependency_service import extract_agent_soul_dependenciesfrom services.agent.dsl_entities import (AgentAppDsl,- AgentPackageWorkspaceSkill,make_agent_app_dsl,- make_portable_agent_package,)from services.agent.errors import (AgentNotFoundError,AgentVersionNotFoundError,- RosterAgentPackageExportFailedError,RosterAgentPackageTooLargeError,)+from services.agent.package_resource_exporter import AgentPackageResourceExporter, _Storagefrom services.agent.roster_package_entities import (ROSTER_AGENT_PACKAGE_FORMAT,ROSTER_AGENT_PACKAGE_FORMAT_VERSION,RosterAgentPackageApp,RosterAgentPackageAudit,RosterAgentPackageExport,- RosterAgentPackageFile,RosterAgentPackageManifest,- RosterAgentPackageSkill,)from services.agent.roster_service import AgentRosterService-from services.agent.skill_package_service import SkillPackageError, SkillPackageServicefrom services.plugin.dependencies_analysis import DependenciesAnalysisService-from services.skill_management_service import RuntimeAgentSkillArchive, SkillManagementService---class _Storage(Protocol):- def load_stream(self, filename: str) -> Generator[bytes, None, None]: ...---@dataclass(frozen=True)-class _SkillSource:- path: str- storage_key: str- id: str- scope: Literal["agent_config", "workspace"]- name: str- display_name: str | None- description: str- priority: int | None- audit_ref: str---@dataclass(frozen=True)-class _FileSource:- path: str- storage_key: str- id: str- audit_ref: strclass RosterAgentPackageExporter:@@ -101,6 +66,7 @@ class RosterAgentPackageExporter:def export(self, *, tenant_id: str, agent_id: str, version_id: UUID | None) -> RosterAgentPackageExport:"""Export a visible version, or the shared draft with an active snapshot fallback."""+ resources = AgentPackageResourceExporter(storage_backend=self._storage)with session_factory.create_session() as session:row = session.execute(select(Agent, App)@@ -160,121 +126,42 @@ class RosterAgentPackageExporter:raise AgentVersionNotFoundError()soul = AgentSoulConfig.model_validate(active_snapshot.config_snapshot_dict)- resource_soul, skill_sources, file_sources = self._collect_payloads(+ package = resources.collect_package(session=session,- tenant_id=tenant_id,+ agent=agent,soul=soul,+ snapshot_id=snapshot_id,+ package_ref="agent_1",+ include_draft=draft is not None,)- package = make_portable_agent_package(agent, resource_soul, include_assets=True)app = make_agent_app_dsl(app_model, package_ref="agent_1", packages={"agent_1": package}, dependencies=[])audit = RosterAgentPackageAudit(ref=agent.id)dependency_ids = extract_agent_soul_dependencies(package.soul)- workspace_skills = SkillManagementService().list_runtime_agent_skill_archives(- tenant_id=tenant_id,- agent_id=agent_id,- include_draft=draft is not None,- config_snapshot_id=snapshot_id,- )- skill_sources.extend(- self._workspace_skill_sources(- soul=package.soul,- archives=workspace_skills,- start_index=len(skill_sources),- )- )- package.workspace_skills = [- AgentPackageWorkspaceSkill(- name=item.name,- display_name=item.display_name or "",- description=item.description,- priority=item.priority,- )- for item in skill_sources- if item.scope == "workspace" and item.priority is not None- ]+ resources.collect_workspace_skills()app.dependencies = self._dependency_provider(tenant_id, dependency_ids)return self._build_archive(app=app,audit=audit,- skill_sources=skill_sources,- file_sources=file_sources,+ resources=resources,)def _build_archive(self,*,app: AgentAppDsl,- skill_sources: Sequence[_SkillSource],- file_sources: Sequence[_FileSource],+ resources: AgentPackageResourceExporter,audit: RosterAgentPackageAudit | None = None,) -> RosterAgentPackageExport:- required_entries = len(skill_sources) + len(file_sources) + 2- if required_entries > dify_config.AGENT_PACKAGE_MAX_ENTRIES:- raise RosterAgentPackageTooLargeError("Roster Agent package has too many members")-# Ownership is transferred to RosterAgentPackageExport.output = cast(BinaryIO,tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b"), # noqa: SIM115)try:- skills: list[RosterAgentPackageSkill] = []- files: list[RosterAgentPackageFile] = []with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_STORED, allowZip64=True) as archive:- total_size = 0- nested_uncompressed_size = 0- skill_packages = SkillPackageService()- sources: list[_SkillSource | _FileSource] = [*skill_sources, *file_sources]- for source in sources:- remaining_bytes = dify_config.AGENT_PACKAGE_MAX_BYTES - total_size- if isinstance(source, _SkillSource):- remaining_bytes = min(remaining_bytes, dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024)- member_size, member_digest = self._write_storage_member(- archive, path=source.path, storage_key=source.storage_key, max_bytes=remaining_bytes- )- total_size += member_size- if isinstance(source, _SkillSource):- # Inspect only the embedded Skill; our writer already owns- # the outer container, resource sizes, and digests.- try:- inspection = skill_packages.inspect(content=archive.read(source.path), filename=source.path)- except SkillPackageError as exc:- raise RosterAgentPackageExportFailedError(- f"Roster Agent package contains unusable Skill {source.name!r}"- ) from exc- if inspection.name != source.name:- raise RosterAgentPackageExportFailedError(- f"Roster Agent package contains unusable Skill {source.name!r}: name mismatch"- )- nested_uncompressed_size += inspection.uncompressed_size- if nested_uncompressed_size > dify_config.AGENT_PACKAGE_MAX_BYTES:- raise RosterAgentPackageTooLargeError(- "Roster Agent package nested Skill contents exceed the size limit"- )-- skills.append(- RosterAgentPackageSkill(- id=source.id,- scope=source.scope,- name=source.name,- path=source.path,- size=member_size,- sha256=member_digest,- audit=RosterAgentPackageAudit(ref=source.audit_ref),- )- )- else:- files.append(- RosterAgentPackageFile(- id=source.id,- path=source.path,- size=member_size,- sha256=member_digest,- audit=RosterAgentPackageAudit(ref=source.audit_ref),- )- )-+ groups, total_size = resources.write_resources(archive)+ group = groups[app.agent.package_ref]app_bytes = yaml.safe_dump(app.model_dump(mode="json", exclude_none=True), allow_unicode=True, sort_keys=False).encode("utf-8")@@ -287,8 +174,8 @@ class RosterAgentPackageExporter:path="app.yaml", size=len(app_bytes), sha256=hashlib.sha256(app_bytes).hexdigest())],- skills=skills,- files=files,+ skills=group.skills,+ files=group.files,)manifest.validate_apps({"app.yaml": app})manifest_bytes = yaml.safe_dump(@@ -315,163 +202,6 @@ class RosterAgentPackageExporter:output.close()raise- def _collect_payloads(- self,- *,- session: Session,- tenant_id: str,- soul: AgentSoulConfig,- ) -> tuple[AgentSoulConfig, list[_SkillSource], list[_FileSource]]:- resource_data = soul.model_dump(mode="json")- skill_sources: list[_SkillSource] = []- file_sources: list[_FileSource] = []-- skill_file_ids = [item.file_id for item in soul.config_skills if not item.is_missing]- tool_files = self._tool_files(session=session, tenant_id=tenant_id, file_ids=skill_file_ids)- for skill_ref, portable_skill_ref in zip(soul.config_skills, resource_data["config_skills"]):- if skill_ref.is_missing:- continue- resource_id = f"s_{len(skill_sources) + 1:06d}"- tool_file = tool_files.get(skill_ref.file_id)- if tool_file is None:- raise RosterAgentPackageExportFailedError(f"Config skill {skill_ref.name!r} payload is unavailable")- path = f"{resource_id}.zip"- portable_skill_ref["file_id"] = resource_id- portable_skill_ref["is_missing"] = False- skill_sources.append(- _SkillSource(- path=path,- storage_key=tool_file.file_key,- id=resource_id,- scope="agent_config",- name=skill_ref.name,- display_name=None,- description=skill_ref.description,- priority=None,- audit_ref=tool_file.id,- )- )-- tool_file_refs = [- item.file_id for item in soul.config_files if not item.is_missing and item.file_kind == "tool_file"- ]- upload_file_refs = [- item.file_id for item in soul.config_files if not item.is_missing and item.file_kind == "upload_file"- ]- file_tool_files = self._tool_files(session=session, tenant_id=tenant_id, file_ids=tool_file_refs)- upload_files = self._upload_files(session=session, tenant_id=tenant_id, file_ids=upload_file_refs)- for file_ref, portable_file_ref in zip(soul.config_files, resource_data["config_files"]):- if file_ref.is_missing:- continue- resource_id = f"f_{len(file_sources) + 1:06d}"- extension = self._safe_extension(file_ref.name)- path = f"{resource_id}{extension}"- if file_ref.file_kind == "tool_file":- tool_file = file_tool_files.get(file_ref.file_id)- if tool_file is None:- raise RosterAgentPackageExportFailedError(f"Config file {file_ref.name!r} payload is unavailable")- storage_key = tool_file.file_key- mime_type = file_ref.mime_type or tool_file.mimetype- audit_ref = tool_file.id- else:- upload_file = upload_files.get(file_ref.file_id)- if upload_file is None:- raise RosterAgentPackageExportFailedError(f"Config file {file_ref.name!r} payload is unavailable")- storage_key = upload_file.key- mime_type = file_ref.mime_type or upload_file.mime_type- audit_ref = upload_file.id- portable_file_ref["file_id"] = resource_id- portable_file_ref["is_missing"] = False- portable_file_ref["mime_type"] = mime_type or "application/octet-stream"- file_sources.append(- _FileSource(- path=path,- storage_key=storage_key,- id=resource_id,- audit_ref=audit_ref,- )- )-- return AgentSoulConfig.model_validate(resource_data), skill_sources, file_sources-- @staticmethod- def _workspace_skill_sources(- *, soul: AgentSoulConfig, archives: Sequence[RuntimeAgentSkillArchive], start_index: int- ) -> list[_SkillSource]:- sources: list[_SkillSource] = []- effective_skill_names = {item.name for item in soul.config_skills if not item.is_missing}- for archive in sorted(archives, key=lambda item: item.priority):- if archive.name in effective_skill_names:- continue- effective_skill_names.add(archive.name)- resource_id = f"s_{start_index + len(sources) + 1:06d}"- path = f"{resource_id}.zip"- sources.append(- _SkillSource(- path=path,- storage_key=archive.storage_key,- id=resource_id,- scope="workspace",- name=archive.name,- display_name=archive.display_name,- description=archive.description,- priority=archive.priority,- audit_ref=archive.version_id,- )- )- return sources-- @staticmethod- def _tool_files(*, session: Session, tenant_id: str, file_ids: Sequence[str]) -> dict[str, ToolFile]:- if not file_ids:- return {}- rows = session.scalars(- select(ToolFile).where(ToolFile.tenant_id == tenant_id, ToolFile.id.in_(set(file_ids)))- ).all()- return {item.id: item for item in rows}-- @staticmethod- def _upload_files(*, session: Session, tenant_id: str, file_ids: Sequence[str]) -> dict[str, UploadFile]:- if not file_ids:- return {}- rows = session.scalars(- select(UploadFile).where(UploadFile.tenant_id == tenant_id, UploadFile.id.in_(set(file_ids)))- ).all()- return {item.id: item for item in rows}-- def _write_storage_member(- self,- archive: zipfile.ZipFile,- *,- path: str,- storage_key: str,- max_bytes: int,- ) -> tuple[int, str]:- digest = hashlib.sha256()- size = 0- try:- with archive.open(path, "w", force_zip64=True) as target:- for chunk in self._storage.load_stream(storage_key):- if not isinstance(chunk, bytes):- raise TypeError("storage stream returned a non-bytes chunk")- if size + len(chunk) > max_bytes:- raise RosterAgentPackageTooLargeError("Roster Agent package payload exceeds the size limit")- size += len(chunk)- digest.update(chunk)- target.write(chunk)- except RosterAgentPackageTooLargeError:- raise- except Exception as exc:- raise RosterAgentPackageExportFailedError(f"Unable to read package resource {path!r}") from exc- return size, digest.hexdigest()-- @staticmethod- def _safe_extension(filename: str) -> str:- extension = os.path.splitext(filename)[1].lower()- if not extension or not re.fullmatch(r"\.[a-z0-9]{1,16}", extension):- return ".bin"- return extension-@staticmethoddef _safe_slug(name: str) -> str:slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")diff --git a/api/services/agent/roster_package_importer.py b/api/services/agent/roster_package_importer.pyindex bdc9bfe7b5b..97f8338f58c 100644--- a/api/services/agent/roster_package_importer.py+++ b/api/services/agent/roster_package_importer.py@@ -2,21 +2,17 @@from __future__ import annotations-import hashlibimport logging-import osfrom dataclasses import dataclass-from typing import BinaryIO, Protocol+from typing import BinaryIOfrom uuid import uuid4from sqlalchemy import select, updatefrom sqlalchemy.exc import IntegrityError-from configs import dify_configfrom constants.model_template import default_app_templatesfrom core.db.session_factory import session_factoryfrom extensions.ext_storage import storage-from extensions.storage.storage_type import StorageTypefrom libs.datetime_utils import naive_utc_nowfrom models import Accountfrom models.agent import (@@ -30,39 +26,28 @@ from models.agent import (AgentStatus,)from models.agent_config_entities import AgentSoulConfig-from models.enums import CreatorUserRolefrom models.model import App, AppMode, AppModelConfig, UploadFile-from models.tools import ToolFile-from services.agent.composer_validator import ComposerConfigValidator-from services.agent.dsl_entities import AgentPackage, AgentPackageMetadata, make_portable_agent_soul+from services.agent.dsl_entities import AgentPackage, AgentPackageMetadatafrom services.agent.dsl_service import AgentDslServicefrom services.agent.errors import (AgentNameConflictError,- InvalidComposerConfigError,InvalidRosterAgentPackageError,- PlaintextSecretNotAllowedError,RosterAgentPackageImportFailedError,RosterAgentPackageResourceUnavailableError,RosterAgentPackageTooLargeError,)+from services.agent.package_resource_importer import AgentPackageResourceImporter, _Storagefrom services.agent.roster_package_dependencies import check_package_dependencies-from services.agent.roster_package_entities import PreparedRosterAgentPackagefrom services.agent.roster_package_reader import RosterAgentPackageReaderfrom services.agent.roster_service import AgentRosterService-from services.agent.skill_package_service import SkillPackageError, SkillPackageServicefrom services.app_creation_records import create_installed_app_record, create_site_recordfrom services.app_service import AppServicefrom services.entities.dsl_entities import DslImportWarning-from services.file_service import FileServicefrom services.icon_configuration import DEFAULT_ICON, DEFAULT_ICON_BACKGROUND, DEFAULT_ICON_TYPElogger = logging.getLogger(__name__)-class _Storage(Protocol):- def save(self, filename: str, data: bytes) -> None: ...--@dataclass(frozen=True)class RosterAgentPackageImportResult:app_id: str@@ -73,14 +58,8 @@ class RosterAgentPackageImportResult:class RosterAgentPackageImporter:"""Commit uploaded file records before creating the Agent in a separate transaction."""- def __init__(- self,- *,- storage_backend: _Storage = storage,- ) -> None:- self._reader = RosterAgentPackageReader()- self._skill_packages = SkillPackageService()- self._storage = storage_backend+ def __init__(self, *, storage_backend: _Storage = storage) -> None:+ self._resources = AgentPackageResourceImporter(storage_backend=storage_backend)def import_package(self,@@ -89,23 +68,19 @@ class RosterAgentPackageImporter:tenant_id: str,account: Account,) -> RosterAgentPackageImportResult:- with self._reader.read(source) as package:+ with RosterAgentPackageReader().read(source) as package:if len(package.apps) != 1:raise InvalidRosterAgentPackageError("Import requires exactly one Agent App")app_dsl = next(iter(package.apps.values()))agent_package = app_dsl.package- agent_package.soul = make_portable_agent_soul(agent_package.soul)- self._validate_supported_resources(package, soul=agent_package.soul)- try:- ComposerConfigValidator.validate_importable_agent_soul(agent_package.soul)- except (InvalidComposerConfigError, PlaintextSecretNotAllowedError) as exc:- raise InvalidRosterAgentPackageError("Roster Agent package Soul is invalid") from exc+ self._resources.validate(resources=package.manifest, agent_package=agent_package)check_package_dependencies(tenant_id=tenant_id, account=account, dependencies=app_dsl.dependencies)try:self._ensure_name_available(tenant_id=tenant_id, name=agent_package.metadata.name)- soul, skill_warnings = self._upload_resources(- package=package,+ materialized, skill_warnings = self._resources.materialize(+ archive=package,+ resources=package.manifest,agent_package=agent_package,tenant_id=tenant_id,account_id=account.id,@@ -113,7 +88,7 @@ class RosterAgentPackageImporter:with session_factory.create_session() as session:resolved_soul, warnings = AgentDslService(session).resolve_package_soul(tenant_id=tenant_id,- package=AgentPackage(metadata=agent_package.metadata, soul=soul),+ package=AgentPackage(metadata=agent_package.metadata, soul=materialized.soul),package_path="agent",)warnings = [*skill_warnings, *warnings]@@ -149,29 +124,6 @@ class RosterAgentPackageImporter:)return RosterAgentPackageImportResult(app_id=app_id, agent_id=agent_id, warnings=warnings)- @classmethod- def _validate_supported_resources(cls, package: PreparedRosterAgentPackage, *, soul: AgentSoulConfig) -> None:- skill_names = [item.name for item in soul.config_skills]- skill_names.extend(item.name for item in package.manifest.skills if item.scope == "workspace")- if len(skill_names) != len(set(skill_names)):- raise InvalidRosterAgentPackageError("Roster Agent package contains duplicate effective Skill names")- file_names = [item.name for item in soul.config_files]- if len(file_names) != len(set(file_names)):- raise InvalidRosterAgentPackageError("Roster Agent package contains duplicate config file names")- file_refs = {item.file_id: item for item in soul.config_files if not item.is_missing}- for resource in package.manifest.files:- filename = file_refs[resource.id].name- extension = cls._extension(filename)- limit = FileService.file_size_limit(extension=extension)- if resource.size > limit:- raise InvalidRosterAgentPackageError(- f"Roster Agent package file {filename!r} exceeds its file size limit"- )- if extension and extension in dify_config.UPLOAD_FILE_EXTENSION_BLACKLIST:- raise InvalidRosterAgentPackageError(- f"Roster Agent package file extension '.{extension}' is not allowed"- )-@staticmethoddef _ensure_name_available(*, tenant_id: str, name: str) -> None:with session_factory.create_session() as session:@@ -188,159 +140,6 @@ class RosterAgentPackageImporter:if exists is not None:raise AgentNameConflictError()- def _upload_resources(- self,- *,- package: PreparedRosterAgentPackage,- agent_package: AgentPackage,- tenant_id: str,- account_id: str,- ) -> tuple[AgentSoulConfig, list[DslImportWarning]]:- """Upload outside database transactions, then commit all file records together."""- files: list[ToolFile | UploadFile] = []- warnings: list[DslImportWarning] = []- soul_data = agent_package.soul.model_dump(mode="json")- skill_refs_by_package_id = {- item["file_id"]: item for item in soul_data["config_skills"] if not item["is_missing"]- }- file_refs_by_package_id = {- item["file_id"]: item for item in soul_data["config_files"] if not item["is_missing"]- }-- skill_descriptions = {item.name: item.description for item in agent_package.workspace_skills}- skill_descriptions.update({item.name: item.description for item in agent_package.soul.config_skills})- for skill_resource in package.manifest.skills:- target_ref = skill_refs_by_package_id.get(skill_resource.id)- if target_ref is None:- target_ref = {}- soul_data["config_skills"].append(target_ref)- target_ref.update(- {- "name": skill_resource.name,- "description": skill_descriptions.get(skill_resource.name, ""),- "file_kind": "tool_file",- "file_id": "",- "is_missing": True,- "size": skill_resource.size,- "hash": skill_resource.sha256,- "mime_type": "application/zip",- }- )- reason = package.invalid_skills.get(skill_resource.id)- normalized = None- try:- if reason is None:- payload = self._reader.read_member_bytes(- package,- skill_resource.path,- max_bytes=dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024,- )- normalized = self._skill_packages.validate_and_normalize(- content=payload, filename=skill_resource.path- )- except SkillPackageError as exc:- reason = exc.code- except InvalidRosterAgentPackageError:- reason = "archive_integrity_failed"- if normalized is None:- warnings.append(- DslImportWarning(- code="agent_skill_missing",- path=f"skills.{skill_resource.id}",- message=f"Skill {skill_resource.name!r} is damaged and must be uploaded again.",- details={"name": skill_resource.name, "reason": reason, "path": skill_resource.path},- )- )- continue- storage_key = f"tools/{tenant_id}/{uuid4().hex}.zip"- tool_file = ToolFile(- user_id=account_id,- tenant_id=tenant_id,- conversation_id=None,- file_key=storage_key,- mimetype="application/zip",- name=f"{skill_resource.name}.zip",- size=len(normalized.archive_bytes),- original_url=None,- )- self._save_resource(storage_key=storage_key, payload=normalized.archive_bytes, files=files, row=tool_file)- target_ref.update(- {- "description": normalized.manifest.description,- "file_id": tool_file.id,- "is_missing": False,- "size": tool_file.size,- "hash": normalized.manifest.hash,- }- )-- for file_resource in package.manifest.files:- package_ref = file_refs_by_package_id[file_resource.id]- file_kind = package_ref["file_kind"]- mime_type = package_ref["mime_type"] or "application/octet-stream"- extension = self._extension(package_ref["name"])- payload = self._reader.read_member_bytes(package, file_resource.path, max_bytes=file_resource.size)- if file_kind == "tool_file":- storage_key = f"tools/{tenant_id}/{uuid4().hex}.{extension or 'bin'}"- row: ToolFile | UploadFile = ToolFile(- user_id=account_id,- tenant_id=tenant_id,- conversation_id=None,- file_key=storage_key,- mimetype=mime_type,- name=package_ref["name"],- size=len(payload),- original_url=None,- )- hash_value = None- else:- storage_key = f"upload_files/{tenant_id}/{uuid4()}.{extension or 'bin'}"- now = naive_utc_now()- row = UploadFile(- tenant_id=tenant_id,- storage_type=StorageType(dify_config.STORAGE_TYPE),- key=storage_key,- name=package_ref["name"],- size=len(payload),- extension=extension,- mime_type=mime_type,- created_by_role=CreatorUserRole.ACCOUNT,- created_by=account_id,- created_at=now,- used=False,- hash=hashlib.sha3_256(payload).hexdigest(),- )- hash_value = row.hash- self._save_resource(storage_key=storage_key, payload=payload, files=files, row=row)- package_ref.update(- {- "file_id": row.id,- "is_missing": False,- "size": row.size,- "hash": hash_value,- "mime_type": mime_type,- }- )-- soul = AgentSoulConfig.model_validate(soul_data)- with session_factory.create_session() as session, session.begin():- session.add_all(files)- return soul, warnings-- def _save_resource(- self,- *,- storage_key: str,- payload: bytes,- files: list[ToolFile | UploadFile],- row: ToolFile | UploadFile,- ) -> None:- try:- self._storage.save(storage_key, payload)- except Exception as exc:- raise RosterAgentPackageResourceUnavailableError() from exc- files.append(row)-@staticmethoddef _persist_import(*,@@ -426,9 +225,5 @@ class RosterAgentPackageImporter:created_records_initialized=True,)- @staticmethod- def _extension(filename: str) -> str:- return os.path.splitext(filename)[1].lstrip(".").lower()-__all__ = ["RosterAgentPackageImportResult", "RosterAgentPackageImporter"]diff --git a/api/services/agent/roster_package_reader.py b/api/services/agent/roster_package_reader.pyindex 7fb01f22971..066f4627692 100644--- a/api/services/agent/roster_package_reader.py+++ b/api/services/agent/roster_package_reader.py@@ -9,7 +9,7 @@ import statimport tempfileimport zipfileimport zlib-from collections.abc import Hashable+from collections.abc import Hashable, Sequencefrom typing import Any, BinaryIO, cast, overrideimport yaml@@ -21,8 +21,10 @@ from services.agent.dsl_entities import AgentAppDslfrom services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeErrorfrom services.agent.roster_package_entities import (ROSTER_AGENT_PACKAGE_MAX_SIGNATURE_BYTES,+ PreparedPackageArchive,PreparedRosterAgentPackage,RosterAgentPackageApp,+ RosterAgentPackageFile,RosterAgentPackageManifest,RosterAgentPackageMember,RosterAgentPackageSkill,@@ -61,7 +63,7 @@ class RosterAgentPackageReader:spool.close()raise- def read_member_bytes(self, package: PreparedRosterAgentPackage, path: str, *, max_bytes: int) -> bytes:+ def read_member_bytes(self, package: PreparedPackageArchive, path: str, *, max_bytes: int) -> bytes:"""Read one already-validated member while rechecking its size and digest."""member = package.members.get(path)@@ -138,7 +140,6 @@ class RosterAgentPackageReader:if actual_paths != expected_paths:raise InvalidRosterAgentPackageError("Roster Agent package members do not match the manifest")- nested_uncompressed_size = 0signature_info = info_by_path.get("signature.sig")if signature_info is not None:_, _, signature_size = self._read_member(@@ -152,67 +153,87 @@ class RosterAgentPackageReader:expected_size=signature_info.file_size,)streamed_size += signature_size- for resource in [*manifest.skills, *manifest.files]:- info = info_by_path[resource.path]- payload = b""- remaining_package_bytes = dify_config.AGENT_PACKAGE_MAX_BYTES - streamed_size- if isinstance(resource, RosterAgentPackageSkill):- max_skill_bytes = dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024- if info.file_size > max_skill_bytes:- raise RosterAgentPackageTooLargeError(- f"Roster Agent package Skill {resource.name!r} exceeds the size limit"- )- try:- payload, digest, actual_size = self._read_member(- archive,- info,- collect=True,- max_bytes=min(max_skill_bytes, remaining_package_bytes),- expected_size=resource.size,- )- except (InvalidRosterAgentPackageError, zipfile.BadZipFile, EOFError, zlib.error):- invalid_skills[resource.id] = "archive_integrity_failed"- streamed_size += info.file_size- continue- else:- _, digest, actual_size = self._read_member(- archive,- info,- collect=False,- max_bytes=remaining_package_bytes,- expected_size=resource.size,- )- streamed_size += actual_size- if digest != resource.sha256:- if isinstance(resource, RosterAgentPackageSkill):- invalid_skills[resource.id] = "checksum_mismatch"- continue- raise InvalidRosterAgentPackageError(- f"Roster Agent package resource {resource.path!r} failed integrity checks",- )- members[resource.path] = RosterAgentPackageMember(- size=resource.size,- sha256=digest,- )- if isinstance(resource, RosterAgentPackageSkill):- try:- inspection = self._skill_packages.inspect(content=payload, filename=resource.path)- except SkillPackageError as exc:- invalid_skills[resource.id] = exc.code- continue- nested_uncompressed_size += inspection.uncompressed_size- if nested_uncompressed_size > dify_config.AGENT_PACKAGE_MAX_BYTES:- raise RosterAgentPackageTooLargeError(- "Roster Agent package nested Skill contents exceed the size limit"- )- if inspection.name != resource.name:- invalid_skills[resource.id] = "skill_name_mismatch"+ self._validate_resource_members(+ archive,+ info_by_path,+ [*manifest.skills, *manifest.files],+ members=members,+ invalid_skills=invalid_skills,+ streamed_size=streamed_size,+ )return manifest, apps, membersexcept (InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError):raiseexcept (OSError, zipfile.BadZipFile, EOFError, RuntimeError, ValueError, zlib.error) as exc:raise InvalidRosterAgentPackageError("Roster Agent package is not a valid ZIP") from exc+ def _validate_resource_members(+ self,+ archive: zipfile.ZipFile,+ info_by_path: dict[str, zipfile.ZipInfo],+ resources: Sequence[RosterAgentPackageSkill | RosterAgentPackageFile],+ *,+ members: dict[str, RosterAgentPackageMember],+ invalid_skills: dict[str, str],+ streamed_size: int,+ ) -> None:+ nested_uncompressed_size = 0+ for resource in resources:+ info = info_by_path[resource.path]+ payload = b""+ remaining_package_bytes = dify_config.AGENT_PACKAGE_MAX_BYTES - streamed_size+ if isinstance(resource, RosterAgentPackageSkill):+ max_skill_bytes = dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024+ if info.file_size > max_skill_bytes:+ raise RosterAgentPackageTooLargeError(+ f"Roster Agent package Skill {resource.name!r} exceeds the size limit"+ )+ try:+ payload, digest, actual_size = self._read_member(+ archive,+ info,+ collect=True,+ max_bytes=min(max_skill_bytes, remaining_package_bytes),+ expected_size=resource.size,+ )+ except (InvalidRosterAgentPackageError, zipfile.BadZipFile, EOFError, zlib.error):+ invalid_skills[resource.id] = "archive_integrity_failed"+ streamed_size += info.file_size+ continue+ else:+ _, digest, actual_size = self._read_member(+ archive,+ info,+ collect=False,+ max_bytes=remaining_package_bytes,+ expected_size=resource.size,+ )+ streamed_size += actual_size+ if digest != resource.sha256:+ if isinstance(resource, RosterAgentPackageSkill):+ invalid_skills[resource.id] = "checksum_mismatch"+ continue+ raise InvalidRosterAgentPackageError(+ f"Roster Agent package resource {resource.path!r} failed integrity checks",+ )+ members[resource.path] = RosterAgentPackageMember(+ size=resource.size,+ sha256=digest,+ )+ if isinstance(resource, RosterAgentPackageSkill):+ try:+ inspection = self._skill_packages.inspect(content=payload, filename=resource.path)+ except SkillPackageError as exc:+ invalid_skills[resource.id] = exc.code+ continue+ nested_uncompressed_size += inspection.uncompressed_size+ if nested_uncompressed_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError(+ "Roster Agent package nested Skill contents exceed the size limit"+ )+ if inspection.name != resource.name:+ invalid_skills[resource.id] = "skill_name_mismatch"+def _index_archive(self, archive: zipfile.ZipFile) -> dict[str, zipfile.ZipInfo]:infos = archive.infolist()if not infos:diff --git a/api/services/app_dsl_service.py b/api/services/app_dsl_service.pyindex c7abd5fd354..d9890a57ea5 100644--- a/api/services/app_dsl_service.py+++ b/api/services/app_dsl_service.py@@ -49,8 +49,10 @@ from models.model import AppModelConfig, AppModelConfigDict, IconType, load_annofrom models.workflow import Workflowfrom services.agent.dsl_entities import AgentPackage, make_agent_app_dslfrom services.agent.dsl_service import AgentDslService+from services.agent.package_resource_exporter import AgentPackageResourceExporterfrom services.agent.retirement_service import WorkflowAgentRetirementServicefrom services.agent.workflow_publish_service import WorkflowAgentPublishService+from services.app_package_service import PreparedAppPackagefrom services.dsl_content import DSL_MAX_SIZE, dsl_content_sizefrom services.dsl_version import check_version_compatibilityfrom services.enterprise.enterprise_service import EnterpriseService@@ -104,6 +106,7 @@ class PendingData(PendingImportOwner):icon: str | None = Noneicon_background: str | None = Noneapp_id: str | None = None+ warnings: list[DslImportWarning] = Field(default_factory=list)class CheckDependenciesPendingData(BaseModel):@@ -181,8 +184,9 @@ class AppDslService:icon_background: str | None = None,app_id: str | None = None,import_app_id: str | None = None,+ package: PreparedAppPackage | None = None,) -> Import:- """Import an app from YAML content or URL."""+ """Import an App DSL, materializing validated archive resources before database writes."""self._warnings = []import_id = str(uuid.uuid4())@@ -282,6 +286,23 @@ class AppDslService:error="Missing app data in YAML content",)+ if package is not None and package.agent_resources:+ tenant_id = account.current_tenant_id+ if tenant_id is None:+ raise ValueError("Current tenant is not set")+ # Authorize overwrites in a separate read session before storage I/O.+ # The normal import below reloads and rechecks the target after upload.+ if app_id:+ with Session(self._session.get_bind()) as authorization_session:+ target = AppDslService(authorization_session)._load_app_for_overwrite(account, app_id)+ if target is None:+ raise ValueError("App not found")+ self._validate_workflow_overwrite(target, data)+ data["agent_packages"], self._warnings = package.materialize_agents(+ tenant_id=tenant_id, account_id=account.id+ )+ content = yaml.safe_dump(data, allow_unicode=True)+# If app_id is provided, check if it existsapp = Noneif app_id:@@ -318,6 +339,7 @@ class AppDslService:icon=icon,icon_background=icon_background,app_id=app_id,+ warnings=self._warnings,)redis_client.setex(f"{IMPORT_INFO_REDIS_KEY_PREFIX}{import_id}",@@ -425,6 +447,7 @@ class AppDslService:error="Import information expired or does not exist",)data = yaml.safe_load(pending_data.yaml_content)+ self._warnings = list(pending_data.warnings)app = Noneif pending_data.app_id:@@ -777,13 +800,36 @@ class AppDslService:workflow_id: str | None = None,version_id: uuid.UUID | None = None,) -> str:+ return yaml.dump(+ cls.export_data(+ app_model,+ session=session,+ include_secret=include_secret,+ workflow_id=workflow_id,+ version_id=version_id,+ ),+ allow_unicode=True,+ )++ @classmethod+ def export_data(+ cls,+ app_model: App,+ *,+ session: Session,+ include_secret: bool = False,+ workflow_id: str | None = None,+ version_id: uuid.UUID | None = None,+ resource_exporter: AgentPackageResourceExporter | None = None,+ ) -> dict[str, Any]:"""- Export app+ Build the App definition before serializing it as YAML or a resource archive.:param app_model: App instance:param session: Database session used to load export data:param include_secret: Whether include secret variable:param workflow_id: Optional published workflow version to export:param version_id: Optional published Agent version to export+ :param resource_exporter: Optional collector for workflow Agent assets in App archives:raises AgentVersionNotFoundError: If the selected Agent version is unavailable or not visible in history:raises WorkflowNotFoundError: If the selected workflow version does not exist:raises IsDraftWorkflowError: If the selected workflow is a draft@@ -811,11 +857,12 @@ class AppDslService:include_secret=include_secret,workflow_id=workflow_id,session=session,+ resource_exporter=resource_exporter,)else:cls._append_model_config_export_data(export_data, app_model, session=session)- return yaml.dump(export_data, allow_unicode=True)+ return export_data@classmethoddef _append_workflow_export_data(@@ -826,6 +873,7 @@ class AppDslService:include_secret: bool,session: Session,workflow_id: str | None = None,+ resource_exporter: AgentPackageResourceExporter | None = None,):"""Append workflow export data@@ -844,6 +892,7 @@ class AppDslService:graph, agent_packages = AgentDslService(session).export_workflow_packages(workflow=workflow,graph=workflow_dict.get("graph", {}),+ resource_exporter=resource_exporter,)workflow_dict["graph"] = graph# TODO: refactor: we need a better way to filter workspace related data from nodesdiff --git a/api/services/app_package_service.py b/api/services/app_package_service.pyindex aae6870ef47..26a5d85d393 100644--- a/api/services/app_package_service.py+++ b/api/services/app_package_service.py@@ -1,101 +1,236 @@-"""Package ordinary App DSLs while retaining the existing Roster Agent format."""+"""Package App DSLs and their node-bound Agent resources."""from __future__ import annotationsimport hashlib-import ioimport reimport tempfileimport zipfileimport zlib-from typing import BinaryIO, Literal, cast+from collections.abc import Iterator+from dataclasses import dataclass+from typing import Any, BinaryIO, Literal, Self, castimport yaml-from pydantic import BaseModel, ConfigDict, Field, ValidationError+from pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator+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 AgentPackagefrom services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError-from services.agent.roster_package_entities import RosterAgentPackageApp, RosterAgentPackageExport+from services.agent.package_resource_exporter import AgentPackageResourceExporter+from services.agent.package_resource_importer import AgentPackageResourceImporter+from services.agent.roster_package_entities import (+ AgentPackageResources,+ PreparedPackageArchive,+ RosterAgentPackageApp,+ RosterAgentPackageExport,+ RosterAgentPackageFile,+ RosterAgentPackageMember,+ RosterAgentPackageSkill,+)from services.agent.roster_package_reader import RosterAgentPackageReaderfrom services.dsl_content import DSL_MAX_SIZE+from services.entities.dsl_entities import DslImportWarningclass AppPackageManifest(BaseModel):+ """Index Agent resources by the same package references used in the workflow DSL."""+model_config = ConfigDict(extra="forbid")format: Literal["dify.app"]format_version: Literal[1]apps: list[RosterAgentPackageApp] = Field(min_length=1, max_length=1)+ agent_resources: dict[str, AgentPackageResources] = Field(default_factory=dict)++ def iter_resources(self) -> Iterator[RosterAgentPackageSkill | RosterAgentPackageFile]:+ for group in self.agent_resources.values():+ yield from group.skills+ yield from group.files++ @model_validator(mode="after")+ def validate_resource_paths(self) -> Self:+ resources = list(self.iter_resources())+ paths = [item.path.casefold() for item in [*self.apps, *resources]]+ ids = [item.id for item in resources]+ if len(paths) != len(set(paths)) or len(ids) != len(set(ids)):+ raise ValueError("App package resources must have unique paths and ids")+ return self+++@dataclass(kw_only=True)+class PreparedAppPackage(PreparedPackageArchive):+ dsl: str+ agents: dict[str, AgentPackage]+ agent_resources: dict[str, AgentPackageResources]++ def materialize_agents(self, *, tenant_id: str, account_id: str) -> tuple[dict[str, Any], list[DslImportWarning]]:+ importer = AgentPackageResourceImporter()+ # Validate every Agent before uploading any resource.+ for ref, resources in self.agent_resources.items():+ importer.validate(resources=resources, agent_package=self.agents[ref])+ agents = dict(self.agents)+ warnings: list[DslImportWarning] = []+ for ref, resources in self.agent_resources.items():+ agents[ref], resource_warnings = importer.materialize(+ archive=self, resources=resources, agent_package=agents[ref], tenant_id=tenant_id, account_id=account_id+ )+ warnings.extend(+ warning.model_copy(update={"path": f"agent_packages.{ref}.{warning.path}"})+ for warning in resource_warnings+ )+ return {ref: agent.model_dump(mode="json") for ref, agent in agents.items()}, warningsclass AppPackageService(RosterAgentPackageReader):- """Reuse the bounded ZIP reader; ordinary Apps retain DSL import semantics."""+ """Reuse the bounded ZIP reader; Apps retain DSL import semantics."""- def read_dsl(self, source: BinaryIO) -> str | None:- """Return an ordinary DSL, or rewind a Roster package for its importer."""+ def read_package(self, source: BinaryIO) -> 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:- with tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b") as spool:- self._copy_bounded(source, cast(BinaryIO, spool))- spool.seek(0)- with zipfile.ZipFile(spool) as archive:- infos = self._index_archive(archive)- data, _ = self._read_yaml_document(archive, infos, "manifest.yaml")- if isinstance(data, dict) and data.get("format") == "dify.roster-agent":- return None- try:- manifest = AppPackageManifest.model_validate(data)- except ValidationError as exc:- raise InvalidRosterAgentPackageError("App package manifest is invalid") from exc- resource = manifest.apps[0]- if set(infos) != {"manifest.yaml", resource.path}:- raise InvalidRosterAgentPackageError("App package members do not match the manifest")- app_data, _ = self._read_yaml_document(- archive, infos, resource.path, resource=resource, max_bytes=DSL_MAX_SIZE- )- if (- not isinstance(app_data, dict)- or app_data.get("kind") != "app"- or not isinstance(app_data.get("app"), dict)- or app_data["app"].get("mode")- not in {- "workflow",- "advanced-chat",- "chat",- "completion",- "agent-chat",- "channel",- "rag-pipeline",- }- ):- raise InvalidRosterAgentPackageError("App package DSL is invalid")- # Preserve the original text for version confirmation and legacy DSL handling.- return archive.read(resource.path).decode("utf-8")+ self._copy_bounded(source, spool)+ spool.seek(0)+ with zipfile.ZipFile(spool) as archive:+ infos = self._index_archive(archive)+ data, manifest_size = self._read_yaml_document(archive, infos, "manifest.yaml")+ if isinstance(data, dict) and data.get("format") == "dify.roster-agent":+ spool.close()+ return None+ try:+ manifest = AppPackageManifest.model_validate(data)+ except ValidationError as exc:+ raise InvalidRosterAgentPackageError("App package manifest is invalid") from exc+ resource = manifest.apps[0]+ resources = list(manifest.iter_resources())+ if set(infos) != {"manifest.yaml", resource.path, *(item.path for item in resources)}:+ raise InvalidRosterAgentPackageError("App package members do not match the manifest")+ app_data, app_size = self._read_yaml_document(+ archive, infos, resource.path, resource=resource, max_bytes=DSL_MAX_SIZE+ )+ if (+ not isinstance(app_data, dict)+ or app_data.get("kind") != "app"+ or not isinstance(app_data.get("app"), dict)+ or app_data["app"].get("mode")+ 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)+ members: dict[str, RosterAgentPackageMember] = {}+ invalid_skills: dict[str, str] = {}+ self._validate_resource_members(+ archive,+ infos,+ resources,+ members=members,+ invalid_skills=invalid_skills,+ streamed_size=manifest_size + app_size,+ )+ # Preserve the original text for version confirmation and legacy DSL handling.+ dsl = archive.read(resource.path).decode("utf-8")+ spool.seek(0)+ return PreparedAppPackage(+ archive=spool,+ dsl=dsl,+ agents=agents,+ agent_resources=manifest.agent_resources,+ members=members,+ invalid_skills=invalid_skills,+ )except (InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError):+ spool.close()raiseexcept (OSError, zipfile.BadZipFile, EOFError, RuntimeError, ValueError, zlib.error) as exc:+ spool.close()raise InvalidRosterAgentPackageError("App package is not a valid ZIP") from exc+ except BaseException:+ spool.close()+ raisefinally:source.seek(0)- def export(self, *, dsl: str, name: str) -> RosterAgentPackageExport:+ @staticmethod+ def _validate_agents(data: dict[str, Any], manifest: AppPackageManifest) -> dict[str, AgentPackage]:+ if not manifest.agent_resources:+ return {}+ try:+ if data["app"]["mode"] not in {"workflow", "advanced-chat"}:+ raise ValueError("Agent resources require a workflow App")+ agents = {ref: AgentPackage.model_validate(value) for ref, value in data["agent_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"]+ 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 {})+ 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():+ group.validate_packages([agents[ref]])+ return agents+ except (KeyError, TypeError, AttributeError, ValueError) as exc:+ raise InvalidRosterAgentPackageError("App package Agent references are invalid") from exc++ def export_app(+ self, *, app_model: App, include_secret: bool = False, workflow_id: str | None = None+ ) -> RosterAgentPackageExport:+ from services.app_dsl_service import AppDslService++ resources = AgentPackageResourceExporter()+ with session_factory.create_session() as session:+ data = AppDslService.export_data(+ app_model=app_model,+ session=session,+ include_secret=include_secret,+ workflow_id=workflow_id,+ resource_exporter=resources,+ )+ resources.collect_workspace_skills()+ if resources.packages:+ data["agent_packages"] = {+ ref: package.model_dump(mode="json") for ref, package in resources.packages.items()+ }+ return self.export(dsl=yaml.dump(data, allow_unicode=True), name=app_model.name, resources=resources)++ def export(+ self, *, dsl: str, name: str, resources: AgentPackageResourceExporter | None = None+ ) -> RosterAgentPackageExport:payload = dsl.encode("utf-8")if len(payload) > DSL_MAX_SIZE:raise RosterAgentPackageTooLargeError("App package DSL exceeds the size limit")- manifest = AppPackageManifest(- format="dify.app",- format_version=1,- apps=[- RosterAgentPackageApp(path="app.yaml", size=len(payload), sha256=hashlib.sha256(payload).hexdigest())- ],- )- archive = io.BytesIO()+ archive = cast(BinaryIO, tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b")) # noqa: SIM115try:with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED) as package:- package.writestr("manifest.yaml", yaml.safe_dump(manifest.model_dump(mode="json")))+ agent_resources, _ = resources.write_resources(package) if resources is not None else ({}, 0)+ manifest = AppPackageManifest(+ format="dify.app",+ format_version=1,+ apps=[+ RosterAgentPackageApp(+ path="app.yaml", size=len(payload), sha256=hashlib.sha256(payload).hexdigest()+ )+ ],+ agent_resources=agent_resources,+ )+ package.writestr(+ "manifest.yaml", yaml.safe_dump(manifest.model_dump(mode="json", exclude_defaults=True))+ )package.writestr("app.yaml", payload)size = archive.tell()archive.seek(0)# Validate exported containers against the same limits as imports.- self.read_dsl(archive)+ validated = self.read_package(archive)+ if validated is None:+ raise InvalidRosterAgentPackageError("Expected an App package")+ validated.close()slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:80] or "app"return RosterAgentPackageExport(archive=archive, filename=f"{slug}.ifpkg", size=size)except Exception:diff --git a/api/tests/unit_tests/controllers/console/app/test_roster_package_routes.py b/api/tests/unit_tests/controllers/console/app/test_roster_package_routes.pyindex 69961b0e4c8..73c81206e7c 100644--- a/api/tests/unit_tests/controllers/console/app/test_roster_package_routes.py+++ b/api/tests/unit_tests/controllers/console/app/test_roster_package_routes.py@@ -3,11 +3,12 @@ import zipfilefrom collections.abc import Callablefrom inspect import unwrapfrom types import SimpleNamespace-from unittest.mock import Mock+from unittest.mock import ANY, Mockfrom uuid import UUIDimport httpximport pytest+import yamlfrom flask import Flaskfrom pydantic import ValidationErrorfrom werkzeug.exceptions import BadRequest, Forbidden@@ -323,10 +324,10 @@ def test_default_export_packages_ordinary_app_dsl() -> None:model = App(id="app-1", tenant_id="tenant-1", mode=mode, name="My App")dsl = f"kind: app\nversion: 0.7.0\napp:\n mode: {mode}\n"- export = Mock(return_value=dsl)+ export = Mock(return_value=yaml.safe_load(dsl))session = object()monkeypatch.setattr(app_module, "db", SimpleNamespace(session=lambda: session))- monkeypatch.setattr(app_module.AppDslService, "export_dsl", export)+ monkeypatch.setattr(app_module.AppDslService, "export_data", export)with app.test_request_context():response = unwrap(app_module.AppExportApi.get)(app_module.AppExportApi(),@@ -336,9 +337,14 @@ def test_default_export_packages_ordinary_app_dsl(response.direct_passthrough = Falseassert response.mimetype == "application/zip"assert "my-app.ifpkg" in response.headers["Content-Disposition"]- assert AppPackageService().read_dsl(io.BytesIO(response.get_data())) == dsl+ prepared = AppPackageService().read_package(io.BytesIO(response.get_data()))+ assert prepared is not None+ with prepared:+ assert yaml.safe_load(prepared.dsl) == yaml.safe_load(dsl)response.close()- export.assert_called_once_with(app_model=model, session=session, include_secret=True, workflow_id="revision-1")+ export.assert_called_once_with(+ app_model=model, session=ANY, include_secret=True, workflow_id="revision-1", resource_exporter=ANY+ )@pytest.mark.parametrize("from_url", [False, True])@@ -380,8 +386,11 @@ def test_ordinary_package_import_uses_dsl_permissions_and_confirmation(with app.test_request_context(method="POST", data=form):assert unwrap(api.post)(api, account) == ({"status": "pending"}, status)import_dsl.assert_called_once_with(- import_module.AppImportPayload(mode="yaml-content", yaml_content=dsl, name="Renamed", app_id=app_id), account+ import_module.AppImportPayload(mode="yaml-content", yaml_content=dsl, name="Renamed", app_id=app_id),+ account,+ package=ANY,)+ assert import_dsl.call_args.kwargs["package"].archive.closedagent_import.assert_not_called()diff --git a/api/tests/unit_tests/services/agent/test_roster_package_service.py b/api/tests/unit_tests/services/agent/test_roster_package_service.pyindex f6bc632a3a8..657c816565a 100644--- a/api/tests/unit_tests/services/agent/test_roster_package_service.py+++ b/api/tests/unit_tests/services/agent/test_roster_package_service.py@@ -10,7 +10,9 @@ import pytestimport yamlfrom flask import Flask, send_filefrom pydantic import ValidationError+from sqlalchemy import Enginefrom sqlalchemy.orm import Session, sessionmaker+from sqlalchemy.pool import QueuePoolfrom configs import dify_configfrom models.agent import (@@ -40,6 +42,7 @@ from services.agent.errors import (RosterAgentPackageResourceUnavailableError,RosterAgentPackageTooLargeError,)+from services.agent.package_resource_exporter import AgentPackageResourceExporter, _FileSource, _SkillSourcefrom services.agent.roster_package_entities import (ROSTER_AGENT_PACKAGE_FORMAT,ROSTER_AGENT_PACKAGE_FORMAT_VERSION,@@ -635,23 +638,22 @@ def test_preflight_rejects_aggregate_nested_skill_expansion(monkeypatch: pytest.with pytest.raises(RosterAgentPackageTooLargeError, match="nested Skill contents"):RosterAgentPackageReader().read(io.BytesIO(package))- exporter = RosterAgentPackageExporter(storage_backend=_MemoryStorage(skill_payloads))+ exporter = RosterAgentPackageExporter()+ resources = AgentPackageResourceExporter(storage_backend=_MemoryStorage(skill_payloads))sources = [- roster_package_exporter_module._SkillSource(+ _SkillSource(path=item.path,storage_key=item.path,id=item.id,scope=item.scope,name=item.name,- display_name=None,- description="Research skill.",- priority=None,audit_ref="source",)for item in manifest.skills]+ resources.sources["agent_1"] = (sources, list[_FileSource]())with pytest.raises(RosterAgentPackageTooLargeError, match="nested Skill contents"):- exporter._build_archive(app=_package_app(soul), skill_sources=sources, file_sources=[])+ exporter._build_archive(app=_package_app(soul), resources=resources)@pytest.mark.parametrize("failure", ["checksum", "size", "name", "crc"])@@ -724,22 +726,21 @@ def test_export_rejects_unusable_or_oversized_skill_payload(payload = _zip({"README.md": b"missing skill manifest"}) if case == "missing_manifest" else _skill_archive("other")if case == "size_limit":apply_config_overrides(monkeypatch, UPLOAD_SKILL_FILE_SIZE_LIMIT=0)- source = roster_package_exporter_module._SkillSource(+ source = _SkillSource(path="s_000001.zip",storage_key="skill",id="s_000001",scope="agent_config",name="research",- display_name=None,- description="Research skill.",- priority=None,audit_ref="source",)app = _package_app()app.package.soul.config_files = []- exporter = RosterAgentPackageExporter(storage_backend=_MemoryStorage({"skill": payload}))+ exporter = RosterAgentPackageExporter()+ resources = AgentPackageResourceExporter(storage_backend=_MemoryStorage({"skill": payload}))+ resources.sources["agent_1"] = ([source], list[_FileSource]())with pytest.raises(error_type, match=message):- exporter._build_archive(app=app, skill_sources=[source], file_sources=[])+ exporter._build_archive(app=app, resources=resources)@pytest.mark.parametrize("max_bytes", [0, 8])@@ -1025,13 +1026,23 @@ def test_export_accepts_legacy_agent_and_preserves_caller_transaction(def test_export_uses_current_workspace_skill_bindings(monkeypatch: pytest.MonkeyPatch,sqlite_session: Session,+ sqlite_engine: Engine,) -> None:monkeypatch.setattr(DependenciesAnalysisService, "generate_dependencies", lambda **_kwargs: [])workspace_payload = _skill_archive("legacy-published")storage = _MemoryStorage({"tools/workspace.zip": workspace_payload})+ pool = sqlite_engine.pool+ assert isinstance(pool, QueuePool)++ def load_legacy_skill(*, tenant_id: str, file_id: str) -> bytes:+ assert tenant_id == "tenant-1"+ assert file_id+ assert pool.checkedout() == 0+ return workspace_payload+monkeypatch.setattr("services.skill_management_service.SkillManagementService._load_tool_file_bytes",- staticmethod(lambda **_kwargs: workspace_payload),+ staticmethod(load_legacy_skill),)archive_file = ToolFile(user_id="account-1",@@ -1323,9 +1334,9 @@ def test_member_read_reports_closed_prepared_archive() -> None:def test_export_download_closes_owned_archive(app: Flask) -> None:- exported = RosterAgentPackageExporter()._build_archive(- app=_package_app(AgentSoulConfig()), skill_sources=[], file_sources=[]- )+ resources = AgentPackageResourceExporter()+ resources.sources["agent_1"] = (list[_SkillSource](), list[_FileSource]())+ exported = RosterAgentPackageExporter()._build_archive(app=_package_app(AgentSoulConfig()), resources=resources)with app.test_request_context("/"):response = send_file(exported.archive, mimetype="application/zip", as_attachment=True, download_name=exported.filename@@ -1358,7 +1369,7 @@ def test_export_preserves_file_metadata_in_dsl(from models.model import UploadFile- exporter = RosterAgentPackageExporter(storage_backend=_MemoryStorage({}))+ exporter = AgentPackageResourceExporter(storage_backend=_MemoryStorage({}))tool_file = ToolFile(user_id="account-1",tenant_id="tenant-1",diff --git a/api/tests/unit_tests/services/agent/test_workflow_package_service.py b/api/tests/unit_tests/services/agent/test_workflow_package_service.pynew file mode 100644index 00000000000..14e884f6d9a--- /dev/null+++ b/api/tests/unit_tests/services/agent/test_workflow_package_service.py@@ -0,0 +1,530 @@+"""Workflow packages restore node-owned Agents and assets across workspaces."""++from __future__ import annotations++import hashlib+import io+import zipfile+from collections.abc import Callable, Generator+from types import SimpleNamespace+from typing import cast+from unittest.mock import Mock++import pytest+import yaml+from sqlalchemy import Engine, select+from sqlalchemy.orm import Session+from sqlalchemy.pool import QueuePool++from models import Account, App, AppMode+from models.agent import (+ Agent,+ AgentConfigSnapshot,+ AgentScope,+ AgentSource,+ AgentStatus,+ WorkflowAgentBindingType,+ WorkflowAgentNodeBinding,+)+from models.agent_config_entities import AgentSoulConfig+from models.model import UploadFile+from models.skill import AgentSkillBinding, AgentSkillBindingSnapshot, Skill, SkillVersion, SkillVersionManifest+from models.tools import ToolFile+from models.workflow import Workflow, WorkflowType+from services.agent.dsl_entities import AgentPackage+from services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageExportFailedError+from services.agent.package_resource_exporter import AgentPackageResourceExporter+from services.agent.package_resource_importer import AgentPackageResourceImporter+from services.app_dsl_service import AppDslService, Import+from services.app_package_service import AppPackageManifest, AppPackageService+from services.entities.dsl_entities import ImportStatus+from services.errors.account import NoPermissionError+from services.plugin.dependencies_analysis import DependenciesAnalysisService+from tests.unit_tests.model_factories import make_account, make_app, make_tenant, make_upload_file, make_workflow+++class _MemoryStorage:+ def __init__(self) -> None:+ self.files: dict[str, bytes] = {}+ self.saved: list[str] = []++ def load_stream(self, filename: str) -> Generator[bytes, None, None]:+ yield self.files[filename]++ def save(self, filename: str, data: bytes) -> None:+ self.files[filename] = data+ self.saved.append(filename)+++def storage(monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine) -> _MemoryStorage:+ backend = _MemoryStorage()+ monkeypatch.setattr("services.workflow_service.db", SimpleNamespace(engine=sqlite_engine))+ monkeypatch.setattr(+ "services.app_package_service.AgentPackageResourceExporter",+ lambda: AgentPackageResourceExporter(storage_backend=backend),+ )+ monkeypatch.setattr(+ "services.app_package_service.AgentPackageResourceImporter",+ lambda: AgentPackageResourceImporter(storage_backend=backend),+ )+ monkeypatch.setattr(DependenciesAnalysisService, "generate_dependencies", lambda **_kwargs: [])+ return backend+++def _skill(name: str, marker: str) -> bytes:+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w") as archive:+ archive.writestr("SKILL.md", f"---\nname: {name}\ndescription: {marker}\n---\n\n# Instructions\n{marker}\n")+ archive.writestr("scripts/run.py", f"print({marker!r})\n")+ return output.getvalue()+++def _tool_file(session: Session, storage: _MemoryStorage, key: str, payload: bytes) -> ToolFile:+ row = ToolFile(+ tenant_id="tenant-1",+ user_id="account-1",+ conversation_id=None,+ file_key=key,+ name=key.rsplit("/", 1)[-1],+ mimetype="application/zip",+ size=len(payload),+ original_url=None,+ )+ storage.files[key] = payload+ session.add(row)+ return row+++def _source(+ session: Session, storage: _MemoryStorage, *, mode: AppMode = AppMode.WORKFLOW, published: bool = False+) -> App:+ app = make_app(mode=mode, name="Inline Workflow")+ nodes = [+ {+ "id": f"node-{index}",+ "data": {"type": "agent", "version": "2", "title": f"Agent {index}", "agent_node_kind": "dify_agent"},+ }+ for index in (1, 2)+ ]+ workflow = make_workflow(+ workflow_id="workflow-1",+ app_id=app.id,+ graph={"nodes": nodes, "edges": []},+ workflow_type=WorkflowType.CHAT if mode == AppMode.ADVANCED_CHAT else WorkflowType.WORKFLOW,+ version="2026-01-01 00:00:00" if published else Workflow.VERSION_DRAFT,+ )+ session.add_all([app, workflow])+ for index in (1, 2):+ skill_file = _tool_file(+ session, storage, f"tools/skill-{index}.zip", _skill("research", f"Agent {index} skill")+ )+ notes = _tool_file(session, storage, f"tools/notes-{index}.txt", f"Agent {index} notes".encode())+ upload = make_upload_file(file_id=f"upload-{index}", key=f"uploads/guide-{index}.txt", name="guide.txt")+ storage.files[upload.key] = f"Agent {index} guide".encode()+ agent = Agent(+ id=f"source-agent-{index}",+ tenant_id=app.tenant_id,+ name=f"Inline {index}",+ scope=AgentScope.WORKFLOW_ONLY,+ source=AgentSource.WORKFLOW,+ app_id=app.id,+ workflow_id=workflow.id,+ workflow_node_id=f"node-{index}",+ status=AgentStatus.ACTIVE,+ created_by="account-1",+ )+ soul = AgentSoulConfig.model_validate(+ {+ "prompt": {"system_prompt": f"Bound snapshot {index}"},+ "config_skills": [{"name": "research", "file_id": skill_file.id}],+ "config_files": [+ {"name": "notes.txt", "file_kind": "tool_file", "file_id": notes.id},+ {"name": "guide.txt", "file_kind": "upload_file", "file_id": upload.id},+ ],+ }+ )+ snapshot = AgentConfigSnapshot(+ id=f"source-snapshot-{index}",+ tenant_id=app.tenant_id,+ agent_id=agent.id,+ version=1,+ config_snapshot=soul,+ created_by="account-1",+ )+ active = AgentConfigSnapshot(+ id=f"active-snapshot-{index}",+ tenant_id=app.tenant_id,+ agent_id=agent.id,+ version=2,+ config_snapshot=AgentSoulConfig.model_validate({"prompt": {"system_prompt": "Unbound active snapshot"}}),+ created_by="account-1",+ )+ agent.active_config_snapshot_id = active.id+ binding = WorkflowAgentNodeBinding(+ tenant_id=app.tenant_id,+ app_id=app.id,+ workflow_id=workflow.id,+ workflow_version=workflow.version,+ node_id=f"node-{index}",+ binding_type=WorkflowAgentBindingType.INLINE_AGENT,+ agent_id=agent.id,+ current_snapshot_id=snapshot.id,+ node_job_config={"workflow_prompt": f"Job {index}"},+ created_by="account-1",+ )+ session.add_all([upload, agent, snapshot, active, binding])+ if index == 1:+ workspace_archive = _tool_file(+ session, storage, "tools/workspace.zip", _skill("workspace", "Workspace skill")+ )+ skill = Skill(+ id="source-workspace-skill",+ tenant_id=app.tenant_id,+ name="workspace",+ display_name="Workspace",+ description="Workspace skill",+ created_by="account-1",+ updated_by="account-1",+ )+ version = SkillVersion(+ id="source-skill-version",+ skill_id=skill.id,+ version_number=1,+ version_name="1.0",+ publish_note="",+ manifest=SkillVersionManifest(+ name="workspace", display_name="Workspace", description="Workspace skill", files=[]+ ),+ archive_tool_file_id=workspace_archive.id,+ archive_size=workspace_archive.size,+ hash_code="workspace-hash",+ published_by="account-1",+ )+ skill.latest_published_version_id = version.id+ session.add_all(+ [+ skill,+ version,+ AgentSkillBindingSnapshot(+ tenant_id=app.tenant_id,+ agent_id=agent.id,+ config_snapshot_id=snapshot.id,+ skill_id=skill.id,+ priority=0,+ created_by="account-1",+ ),+ ]+ )+ session.commit()+ return app+++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))+ assert prepared is not None+ with prepared:+ result = AppDslService(session).import_app(+ account=account or _account(),+ import_mode="yaml-content",+ yaml_content=prepared.dsl,+ app_id=app_id,+ package=prepared,+ )+ if result.status == ImportStatus.FAILED:+ session.rollback()+ else:+ session.commit()+ return result+++def _rewrite(+ content: bytes, mutate: Callable[[AppPackageManifest, dict[str, object], dict[str, bytes]], None]+) -> bytes:+ with zipfile.ZipFile(io.BytesIO(content)) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ manifest = AppPackageManifest.model_validate(yaml.safe_load(members["manifest.yaml"]))+ data = yaml.safe_load(members["app.yaml"])+ mutate(manifest, data, members)+ members["app.yaml"] = yaml.safe_dump(data).encode()+ manifest.apps[0].size = len(members["app.yaml"])+ manifest.apps[0].sha256 = hashlib.sha256(members["app.yaml"]).hexdigest()+ members["manifest.yaml"] = yaml.safe_dump(manifest.model_dump(mode="json")).encode()+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w") as archive:+ for name, payload in members.items():+ archive.writestr(name, payload)+ return output.getvalue()++[email protected]("mode", [AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])[email protected]("published", [False, True])+def test_package_round_trip_restores_bound_agents_and_resources(+ sqlite_session: Session,+ storage: _MemoryStorage,+ mode: AppMode,+ published: bool,+) -> None:+ app = _source(sqlite_session, storage, mode=mode, published=published)+ with AppPackageService().export_app(app_model=app, workflow_id="workflow-1" if published else None) as exported:+ content = exported.archive.read()+ prepared = AppPackageService().read_package(io.BytesIO(content))+ assert prepared is not None+ with prepared:+ assert len(prepared.agent_resources) == 2+ assert [p.soul.prompt.system_prompt for p in prepared.agents.values()] == [+ "Bound snapshot 1",+ "Bound snapshot 2",+ ]+ assert all(not p.omitted_assets for p in prepared.agents.values())+ assert {r.name for group in prepared.agent_resources.values() for r in group.skills} == {+ "research",+ "workspace",+ }+ result = _import(sqlite_session, content)+ assert result.status == ImportStatus.COMPLETED, result.error+ assert result.app_mode == mode+ bindings = sqlite_session.scalars(+ select(WorkflowAgentNodeBinding)+ .where(WorkflowAgentNodeBinding.app_id == result.app_id)+ .order_by(WorkflowAgentNodeBinding.node_id)+ ).all()+ assert len(bindings) == 2+ for index, binding in enumerate(bindings, 1):+ assert binding.tenant_id == "tenant-2"+ assert binding.binding_type == WorkflowAgentBindingType.INLINE_AGENT+ assert binding.node_job_config_dict["workflow_prompt"] == f"Job {index}"+ agent = sqlite_session.get(Agent, binding.agent_id)+ assert agent is not None+ assert (agent.scope, agent.app_id, agent.workflow_id, agent.workflow_node_id) == (+ AgentScope.WORKFLOW_ONLY,+ result.app_id,+ binding.workflow_id,+ binding.node_id,+ )+ snapshot = sqlite_session.get(AgentConfigSnapshot, binding.current_snapshot_id)+ assert snapshot is not None+ soul = AgentSoulConfig.model_validate(snapshot.config_snapshot_dict)+ assert soul.prompt.system_prompt == f"Bound snapshot {index}"+ assert len(soul.config_skills) == (2 if index == 1 else 1)+ for ref in soul.config_skills:+ file = sqlite_session.get(ToolFile, ref.file_id)+ assert file is not None+ assert file.tenant_id == "tenant-2"+ assert not ref.is_missing+ with zipfile.ZipFile(io.BytesIO(storage.files[file.file_key])) as archive:+ expected = f"Agent {index} skill" if ref.name == "research" else "Workspace skill"+ assert expected.encode() in archive.read("SKILL.md")+ for ref in soul.config_files:+ row = sqlite_session.get(ToolFile if ref.file_kind == "tool_file" else UploadFile, ref.file_id)+ assert row is not None+ assert row.tenant_id == "tenant-2"+ key = row.file_key if isinstance(row, ToolFile) else row.key+ expected = f"Agent {index} notes" if ref.name == "notes.txt" else f"Agent {index} guide"+ assert storage.files[key] == expected.encode()+ if isinstance(row, UploadFile):+ assert row.used is True+ assert row.used_by == "account-1"+ assert sqlite_session.scalar(select(AgentSkillBinding).where(AgentSkillBinding.agent_id == agent.id)) is None+++def test_yaml_export_still_omits_resources(sqlite_session: Session, storage: _MemoryStorage) -> None:+ app = _source(sqlite_session, storage)+ data = yaml.safe_load(AppDslService.export_dsl(app, session=sqlite_session))+ for package in data["agent_packages"].values():+ assert package["omitted_assets"]+ assert all(item["is_missing"] and item["file_id"] == "" for item in package["soul"]["config_files"])+++def test_export_rejects_cross_tenant_assets(sqlite_session: Session, storage: _MemoryStorage) -> None:+ app = _source(sqlite_session, storage)+ row = sqlite_session.get(UploadFile, "upload-1")+ assert row is not None+ row.tenant_id = "tenant-elsewhere"+ sqlite_session.commit()+ with pytest.raises(RosterAgentPackageExportFailedError, match="payload is unavailable"):+ AppPackageService().export_app(app_model=app)+++ "mutation", ["unknown_agent", "cross_agent_file", "unreferenced_agent", "duplicate_path", "file_checksum"]+)+def test_rejects_invalid_resource_ownership_before_upload(+ sqlite_session: Session,+ storage: _MemoryStorage,+ mutation: str,+) -> 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:+ resources = manifest.agent_resources+ if mutation == "unknown_agent":+ resources["unknown"] = resources.pop("agent_1")+ elif mutation == "cross_agent_file":+ agents = cast(dict[str, object], data["agent_packages"])+ first = AgentPackage.model_validate(agents["agent_1"])+ second = AgentPackage.model_validate(agents["agent_2"])+ first.soul.config_files[0].file_id = second.soul.config_files[0].file_id+ agents["agent_1"] = first.model_dump(mode="json")+ elif mutation == "unreferenced_agent":+ cast(dict[str, dict[str, list[object]]], data["workflow"])["graph"]["nodes"].pop()+ elif mutation == "duplicate_path":+ resources["agent_2"].files[0] = resources["agent_1"].files[0]+ else:+ resource = resources["agent_1"].files[0]+ members[resource.path] = b"x" * resource.size++ with pytest.raises(InvalidRosterAgentPackageError):+ AppPackageService().read_package(io.BytesIO(_rewrite(content, mutate)))+ assert storage.saved == []+++def test_pending_import_retains_materialized_resources_and_damage_warnings(+ sqlite_session: Session,+ storage: _MemoryStorage,+ monkeypatch: pytest.MonkeyPatch,+) -> 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:+ resources = manifest.agent_resources+ data["version"] = "99.0.0"+ resource = resources["agent_1"].skills[0]+ members[resource.path] = b"x" * resource.size++ 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)+ result = _import(sqlite_session, _rewrite(content, mutate))+ assert result.status == ImportStatus.PENDING+ saved_count = len(storage.saved)+ confirmed = AppDslService(sqlite_session).confirm_import(import_id=result.id, account=_account())+ assert confirmed.status == ImportStatus.COMPLETED_WITH_WARNINGS, confirmed.error+ assert any(+ warning.code == "agent_skill_missing" and warning.path.startswith("agent_packages.agent_1.")+ for warning in confirmed.warnings+ )+ assert len(storage.saved) == saved_count+ assert not pending+++def test_overwrite_permission_is_checked_before_resource_upload(+ sqlite_session: Session,+ storage: _MemoryStorage,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ app = _source(sqlite_session, storage)+ with AppPackageService().export_app(app_model=app) as exported:+ content = exported.archive.read()+ monkeypatch.setattr(AppDslService, "_load_app_for_overwrite", Mock(side_effect=NoPermissionError("Denied")))+ with pytest.raises(NoPermissionError):+ _import(sqlite_session, content, app_id="protected-app")+ assert not storage.saved+++def test_overwrite_replaces_inline_agents_and_reports_previous_owners(+ sqlite_session: Session,+ storage: _MemoryStorage,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ app = _source(sqlite_session, storage)+ with AppPackageService().export_app(app_model=app) as exported:+ content = exported.archive.read()+ original = _import(sqlite_session, content)+ assert original.status == ImportStatus.COMPLETED, original.error+ old_agents = set(+ sqlite_session.scalars(+ select(WorkflowAgentNodeBinding.agent_id).where(WorkflowAgentNodeBinding.app_id == original.app_id)+ )+ )+ sqlite_session.commit()+ retirement = Mock()+ monkeypatch.setattr("services.app_dsl_service.WorkflowAgentRetirementService.retire_unowned", retirement)+ updated = _import(sqlite_session, content, app_id=original.app_id)+ assert updated.status == ImportStatus.COMPLETED, updated.error+ assert updated.app_id == original.app_id+ new_agents = set(+ sqlite_session.scalars(+ select(WorkflowAgentNodeBinding.agent_id).where(WorkflowAgentNodeBinding.app_id == original.app_id)+ )+ )+ assert len(new_agents) == len(old_agents) == 2+ assert not (new_agents & old_agents)+ retirement.assert_called_once_with(tenant_id="tenant-2", agent_ids=old_agents, account_id="account-1")++[email protected]("legacy_skill", [False, True])+def test_resource_io_runs_without_database_transactions(+ sqlite_session: Session,+ storage: _MemoryStorage,+ monkeypatch: pytest.MonkeyPatch,+ legacy_skill: bool,+) -> None:+ app = _source(sqlite_session, storage)+ if legacy_skill:+ version = sqlite_session.get(SkillVersion, "source-skill-version")+ assert version is not None+ version.manifest = version.manifest.model_copy(update={"name": None})+ sqlite_session.commit()+ engine = sqlite_session.get_bind()+ assert isinstance(engine, Engine)+ pool = engine.pool+ assert isinstance(pool, QueuePool)++ def before_io() -> None:+ assert not sqlite_session.in_transaction()+ assert pool.checkedout() == 0++ def load_legacy_skill(*, tenant_id: str, file_id: str) -> bytes:+ assert tenant_id == "tenant-1"+ assert file_id+ before_io()+ return storage.files["tools/workspace.zip"]++ monkeypatch.setattr(+ "services.skill_management_service.SkillManagementService._load_tool_file_bytes",+ staticmethod(load_legacy_skill),+ )+ load_stream = storage.load_stream+ save = storage.save++ def checked_load(filename: str) -> Generator[bytes, None, None]:+ before_io()+ yield from load_stream(filename)++ def checked_save(filename: str, data: bytes) -> None:+ before_io()+ save(filename, data)++ monkeypatch.setattr(storage, "load_stream", checked_load)+ monkeypatch.setattr(storage, "save", checked_save)+ with AppPackageService().export_app(app_model=app) as exported:+ content = exported.archive.read()+ result = _import(sqlite_session, content)+ assert result.status == ImportStatus.COMPLETED, result.error+++def test_missing_assets_remain_explicit_import_warnings(sqlite_session: Session, storage: _MemoryStorage) -> None:+ app = _source(sqlite_session, storage)+ snapshot = sqlite_session.get(AgentConfigSnapshot, "source-snapshot-1")+ assert snapshot is not None+ soul = AgentSoulConfig.model_validate(snapshot.config_snapshot_dict)+ soul.config_files[0].is_missing = True+ soul.config_files[0].file_id = ""+ snapshot.config_snapshot = soul+ sqlite_session.commit()+ with AppPackageService().export_app(app_model=app) as exported:+ result = _import(sqlite_session, exported.archive.read())+ assert result.status == ImportStatus.COMPLETED_WITH_WARNINGS, result.error+ assert any(warning.code == "agent_file_omitted" for warning in result.warnings)diff --git a/api/tests/unit_tests/services/test_app_package_service.py b/api/tests/unit_tests/services/test_app_package_service.pyindex a4299f902c3..159adc9398e 100644--- a/api/tests/unit_tests/services/test_app_package_service.py+++ b/api/tests/unit_tests/services/test_app_package_service.py@@ -36,7 +36,10 @@ def test_round_trip_retains_exact_dsl_and_defers_version_handling(mode: str, verservice = AppPackageService()with service.export(dsl=dsl, name="Example App") as package:assert package.filename == "example-app.ifpkg"- assert service.read_dsl(package.archive) == dsl+ prepared = service.read_package(package.archive)+ assert prepared is not None+ with prepared:+ assert prepared.dsl == dslassert package.archive.tell() == 0assert package.archive.closed@@ -44,7 +47,7 @@ def test_round_trip_retains_exact_dsl_and_defers_version_handling(mode: str, ver@pytest.mark.parametrize("overrides", [{"format": "unknown"}, {"format_version": 2}, {"apps": []}, {"files": []}])def test_rejects_unsupported_manifests(overrides: dict[str, object]) -> None:with pytest.raises(InvalidRosterAgentPackageError, match="manifest"):- AppPackageService().read_dsl(_archive("kind: app\napp: {mode: workflow}\n", **overrides))+ AppPackageService().read_package(_archive("kind: app\napp: {mode: workflow}\n", **overrides))@pytest.mark.parametrize(@@ -58,14 +61,14 @@ def test_rejects_unsupported_manifests(overrides: dict[str, object]) -> None:)def test_rejects_invalid_or_agent_dsl_in_ordinary_container(dsl: str) -> None:with pytest.raises(InvalidRosterAgentPackageError):- AppPackageService().read_dsl(_archive(dsl))+ AppPackageService().read_package(_archive(dsl))def test_rejects_checksum_mismatch() -> None:dsl = "kind: app\napp: {mode: workflow}\n"source = _archive(dsl, apps=[{"path": "app.yaml", "size": len(dsl), "sha256": "0" * 64}])with pytest.raises(InvalidRosterAgentPackageError, match="integrity"):- AppPackageService().read_dsl(source)+ AppPackageService().read_package(source)@pytest.mark.parametrize("path", ["extra.txt", "../escape", "APP.YAML"])@@ -75,14 +78,14 @@ def test_rejects_unlisted_unsafe_and_duplicate_members(path: str) -> None:archive.writestr(path, "unexpected")source.seek(0)with pytest.raises(InvalidRosterAgentPackageError):- AppPackageService().read_dsl(source)+ AppPackageService().read_package(source)def test_rejects_oversized_container(config_overrides: Callable[..., None]) -> None:source = _archive("kind: app\napp: {mode: workflow}\n")config_overrides(AGENT_PACKAGE_MAX_BYTES=10)with pytest.raises(RosterAgentPackageTooLargeError):- AppPackageService().read_dsl(source)+ AppPackageService().read_package(source)def _dsl_with_size(size: int) -> str:@@ -96,7 +99,10 @@ def test_package_round_trip_accepts_large_dsl_within_legacy_limit(size: int) ->dsl = _dsl_with_size(size)service = AppPackageService()with service.export(dsl=dsl, name="Large Workflow") as package:- assert service.read_dsl(package.archive) == dsl+ prepared = service.read_package(package.archive)+ assert prepared is not None+ with prepared:+ assert prepared.dsl == dsldef test_export_rejects_dsl_exceeding_legacy_byte_limit() -> None:@@ -109,4 +115,4 @@ def test_import_rejects_compressed_dsl_exceeding_legacy_byte_limit() -> None:dsl = _dsl_with_size(DSL_MAX_SIZE + 1)source = _archive(dsl)with pytest.raises(RosterAgentPackageTooLargeError):- AppPackageService().read_dsl(source)+ AppPackageService().read_package(source)