Skip to content

armgit / dify

Public Imported from GitHub
0

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

feat(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.py
index 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.py
index 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, PreparedAppPackage
from services.enterprise.enterprise_service import EnterpriseService
from services.entities.dsl_entities import CheckDependenciesResult, ImportStatus
from 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.py
index 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, cast
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field
-from sqlalchemy import func, select
+from sqlalchemy import func, select, update
from sqlalchemy.orm import Session
from core.workflow.nodes.agent_v2.discriminator import is_dify_agent_node_data
from core.workflow.nodes.agent_v2.validators import WorkflowAgentNodeValidator
+from libs.datetime_utils import naive_utc_now
from models import Account
from 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, UploadFile
from models.skill import AgentSkillBinding, AgentSkillBindingSnapshot, Skill
from models.workflow import Workflow
from 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 AgentPackageResourceExporter
from services.agent.roster_service import AgentRosterService
from 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.py
new file mode 100644
index 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 extension
diff --git a/api/services/agent/package_resource_importer.py b/api/services/agent/package_resource_importer.py
new file mode 100644
index 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.py
index 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 annotations
import re
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
from dataclasses import dataclass, field
from typing import BinaryIO, Final, Literal, Self
from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
-from services.agent.dsl_entities import AgentAppDsl
+from services.agent.dsl_entities import AgentAppDsl, AgentPackage
ROSTER_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:
continue
skill_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:
continue
if 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 self
def __exit__(self, *_args: object) -> None:
self.close()
+@dataclass(kw_only=True)
+class PreparedRosterAgentPackage(PreparedPackageArchive):
+ manifest: RosterAgentPackageManifest
+ apps: dict[str, AgentAppDsl]
+
+
@dataclass
class 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.py
index 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 annotations
import hashlib
-import os
import re
import tempfile
import 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, cast
from uuid import UUID
import yaml
from sqlalchemy import or_, select
-from sqlalchemy.orm import Session
from configs import dify_config
from core.db.session_factory import session_factory
@@ -31,60 +28,28 @@ from models.agent import (
)
from models.agent_config_entities import AgentSoulConfig
from models.enums import AppStatus
-from models.model import App, AppMode, UploadFile
-from models.tools import ToolFile
+from models.model import App, AppMode
from services.agent.dependency_service import extract_agent_soul_dependencies
from 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, _Storage
from 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, SkillPackageService
from 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: str
class 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
-
@staticmethod
def _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.py
index 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 hashlib
import logging
-import os
from dataclasses import dataclass
-from typing import BinaryIO, Protocol
+from typing import BinaryIO
from uuid import uuid4
from sqlalchemy import select, update
from sqlalchemy.exc import IntegrityError
-from configs import dify_config
from constants.model_template import default_app_templates
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 import Account
from models.agent import (
@@ -30,39 +26,28 @@ from models.agent import (
AgentStatus,
)
from models.agent_config_entities import AgentSoulConfig
-from models.enums import CreatorUserRole
from 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, AgentPackageMetadata
from services.agent.dsl_service import AgentDslService
from services.agent.errors import (
AgentNameConflictError,
- InvalidComposerConfigError,
InvalidRosterAgentPackageError,
- PlaintextSecretNotAllowedError,
RosterAgentPackageImportFailedError,
RosterAgentPackageResourceUnavailableError,
RosterAgentPackageTooLargeError,
)
+from services.agent.package_resource_importer import AgentPackageResourceImporter, _Storage
from services.agent.roster_package_dependencies import check_package_dependencies
-from services.agent.roster_package_entities import PreparedRosterAgentPackage
from services.agent.roster_package_reader import RosterAgentPackageReader
from services.agent.roster_service import AgentRosterService
-from services.agent.skill_package_service import SkillPackageError, SkillPackageService
from services.app_creation_records import create_installed_app_record, create_site_record
from services.app_service import AppService
from services.entities.dsl_entities import DslImportWarning
-from services.file_service import FileService
from services.icon_configuration import DEFAULT_ICON, DEFAULT_ICON_BACKGROUND, DEFAULT_ICON_TYPE
logger = 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"
- )
-
@staticmethod
def _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)
-
@staticmethod
def _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.py
index 7fb01f22971..066f4627692 100644
--- a/api/services/agent/roster_package_reader.py
+++ b/api/services/agent/roster_package_reader.py
@@ -9,7 +9,7 @@ import stat
import tempfile
import zipfile
import zlib
-from collections.abc import Hashable
+from collections.abc import Hashable, Sequence
from typing import Any, BinaryIO, cast, override
import yaml
@@ -21,8 +21,10 @@ from services.agent.dsl_entities import AgentAppDsl
from services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError
from 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 = 0
signature_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, members
except (InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError):
raise
except (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.py
index 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_anno
from models.workflow import Workflow
from services.agent.dsl_entities import AgentPackage, make_agent_app_dsl
from services.agent.dsl_service import AgentDslService
+from services.agent.package_resource_exporter import AgentPackageResourceExporter
from services.agent.retirement_service import WorkflowAgentRetirementService
from services.agent.workflow_publish_service import WorkflowAgentPublishService
+from services.app_package_service import PreparedAppPackage
from services.dsl_content import DSL_MAX_SIZE, dsl_content_size
from services.dsl_version import check_version_compatibility
from services.enterprise.enterprise_service import EnterpriseService
@@ -104,6 +106,7 @@ class PendingData(PendingImportOwner):
icon: str | None = None
icon_background: str | None = None
app_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 exists
app = None
if 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 = None
if 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
@classmethod
def _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 nodes
diff --git a/api/services/app_package_service.py b/api/services/app_package_service.py
index 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 annotations
import hashlib
-import io
import re
import tempfile
import zipfile
import zlib
-from typing import BinaryIO, Literal, cast
+from collections.abc import Iterator
+from dataclasses import dataclass
+from typing import Any, BinaryIO, Literal, Self, cast
import 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 AgentPackage
from 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 RosterAgentPackageReader
from services.dsl_content import DSL_MAX_SIZE
+from services.entities.dsl_entities import DslImportWarning
class 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()}, warnings
class 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: SIM115
try:
- 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()
raise
except (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()
+ raise
finally:
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: SIM115
try:
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.py
index 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 zipfile
from collections.abc import Callable
from inspect import unwrap
from types import SimpleNamespace
-from unittest.mock import Mock
+from unittest.mock import ANY, Mock
from uuid import UUID
import httpx
import pytest
+import yaml
from flask import Flask
from pydantic import ValidationError
from 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 = False
assert 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.closed
agent_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.py
index 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 pytest
import yaml
from flask import Flask, send_file
from pydantic import ValidationError
+from sqlalchemy import Engine
from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.pool import QueuePool
from configs import dify_config
from models.agent import (
@@ -40,6 +42,7 @@ from services.agent.errors import (
RosterAgentPackageResourceUnavailableError,
RosterAgentPackageTooLargeError,
)
+from services.agent.package_resource_exporter import AgentPackageResourceExporter, _FileSource, _SkillSource
from 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.py
new file mode 100644
index 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.py
index 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, ver
service = 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 == dsl
assert package.archive.tell() == 0
assert 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 == dsl
def 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)