Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
feat(api): bundle called workflow tools in app packages (#44592)
-LAN-2fc0a6712505
diff --git a/api/.env.example b/api/.env.exampleindex 94f189af26b..16226a49fd8 100644--- a/api/.env.example+++ b/api/.env.example@@ -483,6 +483,7 @@ SKILL_PACKAGE_MAX_SKILL_MD_BYTES=1048576AGENT_PACKAGE_MAX_BYTES=536870912AGENT_PACKAGE_MAX_MANIFEST_BYTES=5242880AGENT_PACKAGE_MAX_ENTRIES=5000+APP_PACKAGE_MAX_WORKFLOW_TOOLS=20# Comma-separated list of file extensions blocked from upload for security reasons.# Extensions should be lowercase without dots (e.g., exe,bat,sh,dll).diff --git a/api/configs/feature/__init__.py b/api/configs/feature/__init__.pyindex 2b3f972c508..2ac8c78f331 100644--- a/api/configs/feature/__init__.py+++ b/api/configs/feature/__init__.py@@ -540,6 +540,11 @@ class FileUploadConfig(BaseSettings):default=5000,)+ APP_PACKAGE_MAX_WORKFLOW_TOOLS: PositiveInt = Field(+ description="Maximum number of Workflow Tool workflows bundled into one App package",+ default=20,+ )+BATCH_UPLOAD_LIMIT: NonNegativeInt = Field(description="Maximum number of files allowed in a batch upload operation",default=20,diff --git a/api/services/app/console_gateway.py b/api/services/app/console_gateway.pyindex 8ba6723ea22..869e75c5a87 100644--- a/api/services/app/console_gateway.py+++ b/api/services/app/console_gateway.py@@ -3,26 +3,29 @@from __future__ import annotationsimport copy-from collections.abc import Callable+from collections.abc import Callable, Sequencefrom contextlib import AbstractContextManagerfrom dataclasses import dataclass, replacefrom typing import Any, BinaryIO, Final, Literal, override-from uuid import UUID+from uuid import UUID, uuid4+from sqlalchemy import selectfrom sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.orm import Session, sessionmakerfrom configs import dify_config-from core.rbac import RBACPermission+from core.rbac import RBACPermission, RBACResourceScopefrom enums import DeploymentEditionfrom events.app_event import app_was_updatedfrom graphon.enums import BuiltinNodeTypesfrom graphon.model_runtime.entities.llm_entities import LLMModefrom graphon.model_runtime.entities.message_entities import PromptMessageRole+from libs.datetime_utils import naive_utc_nowfrom machinery.context import RequestContextfrom models.account import Accountfrom models.agent import AgentIconType-from models.model import AppMode+from models.model import App, AppMode+from models.tools import WorkflowToolProviderfrom repositories.app.console_repository import ConsoleAppRepository, console_app_actor, require_console_appfrom repositories.app.response import app_recordfrom services.agent.errors import AgentNameConflictError@@ -65,6 +68,7 @@ from services.entities.dsl_entities import (DraftGuardedImportParams,Import,ImportStatus,+ PackagedWorkflowTool,)from services.errors.base import NoPermissionErrorfrom services.feature_service import FeatureService@@ -72,7 +76,9 @@ from services.rbac import contracts as rbac_contractsfrom services.rbac.members import MemberServicefrom services.recommended_app_package_service import RecommendedAppPackageServicefrom services.system_feature_service import SystemFeatureService+from services.tools.workflow_tools_manage_service import WorkflowToolManageServicefrom services.workflow_service import WorkflowService+from services.workflow_tool_references import WorkflowToolTargetfrom tasks.initialize_created_app_rbac_access_task import initialize_created_app_rbac_access_task# Positions as the console editor lays out its templates (START_INITIAL_POSITION and@@ -415,6 +421,73 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):def check_dependencies(self, context: RequestContext, app_id: str) -> CheckDependenciesResult:return AppDslService.check_app_dependencies(tenant_id=context.active_workspace_id, app_id=app_id)+ @override+ def plan_workflow_tools(+ self, context: RequestContext, tools: Sequence[PackagedWorkflowTool], *, creates_root_app: bool+ ) -> dict[str, WorkflowToolTarget]:+ """Reuse tools that already exist here, and admit, name and reserve ids for the ones to create."""+ workspace_id = context.active_workspace_id+ with self._session_factory() as session:+ account = console_app_actor(session, context)+ existing = {+ provider.id: provider.name+ for provider in session.scalars(+ select(WorkflowToolProvider).where(+ WorkflowToolProvider.tenant_id == workspace_id,+ WorkflowToolProvider.id.in_([tool.provider_id for tool in tools]),+ )+ )+ }+ taken_names = set(+ session.scalars(select(WorkflowToolProvider.name).where(WorkflowToolProvider.tenant_id == workspace_id))+ )+ can_manage_tools = account.is_admin_or_owner+ missing = [tool for tool in tools if tool.provider_id not in existing]+ if missing and dify_config.RBAC_ENABLED:+ can_manage_tools = rbac_service.RBACService.CheckAccess.check(+ workspace_id, context.account_id, scene=RBACPermission.TOOL_MANAGE, resource_type=None, resource_id=None+ )+ if missing and not can_manage_tools:+ raise NoPermissionError("You do not have permission to create the workflow tools this App calls")+ AppDslService.check_app_quota(tenant_id=workspace_id, new_apps=len(missing) + int(creates_root_app))+ targets = {+ provider_id: WorkflowToolTarget(provider_id=provider_id, name=name, create=False)+ for provider_id, name in existing.items()+ }+ for tool in missing:+ name, suffix = tool.name, 2+ while name in taken_names:+ name, suffix = f"{tool.name}_{suffix}", suffix + 1+ taken_names.add(name)+ targets[tool.provider_id] = WorkflowToolTarget(provider_id=str(uuid4()), name=name, create=True)+ return targets++ @override+ def create_workflow_tool(+ self, context: RequestContext, *, app_id: str, tool: PackagedWorkflowTool, target: WorkflowToolTarget+ ) -> None:+ """Publish an imported workflow and expose it as the Workflow Tool its callers already reference."""+ with self._session_factory.begin() as session:+ account = console_app_actor(session, context)+ app = require_console_app(session, context, app_id)+ workflow = WorkflowService().publish_workflow(session=session, app_model=app, account=account)+ app.workflow_id = workflow.id+ app.updated_by = account.id+ app.updated_at = naive_utc_now()+ WorkflowToolManageService.create_workflow_tool(+ user_id=context.account_id,+ tenant_id=context.active_workspace_id,+ workflow_app_id=app_id,+ name=target.name,+ label=tool.label,+ icon=dict(tool.icon),+ description=tool.description,+ parameters=tool.parameters,+ privacy_policy=tool.privacy_policy,+ labels=tool.labels,+ import_id=target.provider_id,+ )+@overridedef export_dsl(self, context: RequestContext, app_id: str, options: AppExportOptions) -> str:with self._session_factory() as session:@@ -441,6 +514,21 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):include_secret=options.include_secret,workflow_id=options.workflow_id,preserve_agent_bindings=options.preserve_agent_bindings,+ may_bundle=lambda called_app: self._may_export_app(context, called_app),+ )++ @staticmethod+ def _may_export_app(context: RequestContext, app: App) -> bool:+ """Apply the export endpoint's App check to a workflow the exported App calls."""+ # Without RBAC, the workspace role the endpoint admitted covers every App in the workspace.+ if not dify_config.RBAC_ENABLED or app.maintainer == context.account_id:+ return True+ return rbac_service.RBACService.CheckAccess.check(+ context.active_workspace_id,+ context.account_id,+ scene=RBACPermission.APP_IMPORT_EXPORT_DSL,+ resource_type=RBACResourceScope.APP,+ resource_id=app.id,)@overridediff --git a/api/services/app/console_service.py b/api/services/app/console_service.pyindex 56b9e6af375..d0f62040c6f 100644--- a/api/services/app/console_service.py+++ b/api/services/app/console_service.py@@ -2,6 +2,8 @@from __future__ import annotations+import logging+from collections.abc import Sequencefrom contextlib import AbstractContextManager, closingfrom dataclasses import replacefrom typing import BinaryIO, Literal, Protocol@@ -33,9 +35,14 @@ from services.entities.dsl_entities import (AppImportPackage,AppImportParams,CheckDependenciesResult,+ DslImportWarning,Import,ImportStatus,+ PackagedWorkflowTool,)+from services.workflow_tool_references import WorkflowToolTarget, retarget_workflow_tool_dsl++logger = logging.getLogger(__name__)class ConsoleAppNotFoundError(Exception):@@ -150,6 +157,14 @@ class AppTransfers(Protocol):def check_dependencies(self, context: RequestContext, app_id: str) -> CheckDependenciesResult: ...+ def plan_workflow_tools(+ self, context: RequestContext, tools: Sequence[PackagedWorkflowTool], *, creates_root_app: bool+ ) -> dict[str, WorkflowToolTarget]: ...++ def create_workflow_tool(+ self, context: RequestContext, *, app_id: str, tool: PackagedWorkflowTool, target: WorkflowToolTarget+ ) -> None: ...+def export_dsl(self, context: RequestContext, app_id: str, options: AppExportOptions) -> str: ...def export_app_package(@@ -259,6 +274,8 @@ class ConsoleAppService:package = self._transfers.read_app_package(source)if package is not None:with closing(package):+ if package.workflow_tools:+ return self._import_with_workflow_tools(context, params, package)return self._import_dsl(context,params.model_copy(update={"mode": "yaml-content", "yaml_content": package.dsl, "yaml_url": None}),@@ -270,6 +287,84 @@ class ConsoleAppService:result = self._transfers.import_agent_package(context, source)return self._import_agent_result(result)+ def _import_with_workflow_tools(+ self, context: RequestContext, params: AppImportParams, package: AppImportPackage+ ) -> Import:+ """Create the workflows a package calls as Workflow Tools, then import the App that calls them.++ Workflow Tools already in the workspace are reused. New tools get their ids up front, so a DSL can+ reference a tool that is created after it and workflows that call each other need no order. Apps+ created before a failure are deleted.+ """+ self._access.require_import(context, "dsl")+ targets = self._transfers.plan_workflow_tools(+ context, package.workflow_tools, creates_root_app=not params.app_id+ )+ created_app_ids: list[str] = []+ warnings: list[DslImportWarning] = []+ try:+ for tool in package.workflow_tools:+ target = targets[tool.provider_id]+ if not target.create:+ continue+ with closing(package.open_workflow_tool(tool)) as workflow_package:+ imported = self._import_dsl(+ context,+ AppImportParams(+ mode="yaml-content",+ yaml_content=retarget_workflow_tool_dsl(workflow_package.dsl, targets),+ ),+ package=workflow_package,+ )+ if imported.app_id and imported.app_created:+ created_app_ids.append(imported.app_id)+ if (+ imported.status not in {ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS}+ or not imported.app_id+ ):+ raise InvalidRosterAgentPackageError(+ f"Workflow tool {tool.name!r} could not be imported: {imported.error}"+ )+ try:+ self._transfers.create_workflow_tool(context, app_id=imported.app_id, tool=tool, target=target)+ except ValueError as exc:+ # Publishing validates the workflow against this workspace, e.g. its Knowledge Bases.+ raise InvalidRosterAgentPackageError(+ f"Workflow tool {tool.name!r} could not be created: {exc}"+ ) from exc+ warnings.extend(+ warning.model_copy(update={"path": f"workflow_tools.{tool.id}.{warning.path}"})+ for warning in imported.warnings+ )+ result = self._import_dsl(+ context,+ params.model_copy(+ update={+ "mode": "yaml-content",+ "yaml_content": retarget_workflow_tool_dsl(package.dsl, targets),+ "yaml_url": None,+ }+ ),+ package=package,+ )+ except Exception:+ self._discard_imported_apps(context, created_app_ids)+ raise+ if result.status == ImportStatus.FAILED:+ self._discard_imported_apps(context, created_app_ids)+ return result+ result.warnings = [*warnings, *result.warnings]+ if result.warnings and result.status == ImportStatus.COMPLETED:+ result.status = ImportStatus.COMPLETED_WITH_WARNINGS+ return result++ def _discard_imported_apps(self, context: RequestContext, app_ids: list[str]) -> None:+ for app_id in reversed(app_ids):+ try:+ self.delete(context, app_id)+ except Exception:+ logger.exception("Failed to delete App %s left by a failed package import", app_id)+def _import_agent_result(self, result: ImportedAppPackage) -> Import:return Import(id=str(uuid4()),diff --git a/api/services/app_dsl_service.py b/api/services/app_dsl_service.pyindex db2d9113828..aa4d815d2ff 100644--- a/api/services/app_dsl_service.py+++ b/api/services/app_dsl_service.py@@ -48,7 +48,7 @@ from graphon.model_runtime.utils.encoders import jsonable_encoderfrom graphon.nodes.llm.entities import LLMNodeData, ModelConfigfrom graphon.nodes.parameter_extractor.entities import ParameterExtractorNodeDatafrom graphon.nodes.question_classifier.entities import QuestionClassifierNodeData-from graphon.nodes.tool.entities import ToolNodeData+from graphon.nodes.tool.entities import ToolNodeData, ToolProviderTypefrom libs.datetime_utils import naive_utc_nowfrom models import Account, App, AppModefrom models.agent import AgentScope, WorkflowAgentBindingType, WorkflowAgentNodeBinding@@ -96,6 +96,8 @@ IMPORT_INFO_REDIS_KEY_PREFIX = "app_import_info:"CHECK_DEPENDENCIES_REDIS_KEY_PREFIX = "app_check_dependencies:"IMPORT_INFO_REDIS_EXPIRY = 10 * 60 # 10 minutesCURRENT_DSL_VERSION = CURRENT_APP_DSL_VERSION+# Other provider types reference workspace records by id, so they never map to a plugin.+PLUGIN_TOOL_PROVIDER_TYPES = frozenset({ToolProviderType.BUILT_IN, ToolProviderType.PLUGIN})def initialize_imported_app_creator_access(result: Import, *, tenant_id: str, account_id: str) -> None:@@ -167,12 +169,19 @@ class AppDslService:tenant_id = account.current_tenant_idif tenant_id is None:raise ValueError("Current tenant is not set")+ AppDslService.check_app_quota(tenant_id=tenant_id, new_apps=1)++ @staticmethod+ def check_app_quota(*, tenant_id: str, new_apps: int) -> None:+ """Reject an import on Cloud when creating ``new_apps`` more Apps would exceed the plan's limit."""+ if dify_config.DEPLOYMENT_EDITION != DeploymentEdition.CLOUD:+ returntry:apps = FeatureService.get_features(tenant_id, exclude_vector_space=True).appsexcept Exception as error:# A failed lookup is a server failure, not an invalid DSL or exhausted quota.raise AppQuotaCheckError("Unable to check the app quota.") from error- if 0 < apps.limit <= apps.size:+ if 0 < apps.limit < apps.size + new_apps:raise NoPermissionError("The number of apps has reached the limit of your subscription.")def import_app(@@ -1220,6 +1229,8 @@ class AppDslService:match typ:case BuiltinNodeTypes.TOOL:tool_entity = ToolNodeData.model_validate(node["data"])+ if tool_entity.provider_type not in PLUGIN_TOOL_PROVIDER_TYPES:+ continuedependencies.append(node_data.get("plugin_id")or DependenciesAnalysisService.analyze_tool_provider_reference(tool_entity.provider_id),@@ -1320,6 +1331,8 @@ class AppDslService:agent_configs = model_config.get("agent_mode", {})if agent_configs:for agent_config in agent_configs.get("tools", []):+ if agent_config.get("provider_type") not in PLUGIN_TOOL_PROVIDER_TYPES:+ continuedependencies.append(DependenciesAnalysisService.analyze_tool_dependency(agent_config.get("provider_id")))diff --git a/api/services/app_package_service.py b/api/services/app_package_service.pyindex b4e7e8a219c..a1fda7d5758 100644--- a/api/services/app_package_service.py+++ b/api/services/app_package_service.py@@ -1,4 +1,4 @@-"""Package App DSLs with Site icons and node-bound Agent resources."""+"""Package App DSLs with Site icons, node-bound Agent resources and the workflows called as Workflow Tools."""from __future__ import annotations@@ -7,18 +7,24 @@ import reimport tempfileimport zipfileimport zlib-from collections.abc import Iterator, Mapping+from collections.abc import Callable, Iterator, Mapping, Sequencefrom dataclasses import dataclass, fieldfrom typing import Any, BinaryIO, Literal, Self, castimport yamlfrom pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator+from sqlalchemy import select+from configs import dify_config+from constants.dsl_version import CURRENT_APP_DSL_VERSIONfrom core.db.session_factory import session_factory+from core.tools.entities.tool_entities import ToolProviderType, emoji_icon_adapterfrom core.workflow.nodes.agent_v2.validators import WorkflowAgentNodeValidatorfrom models.agent import WorkflowAgentBindingTypefrom models.agent_config_entities import WorkflowNodeJobConfigfrom models.model import App, AppMode+from models.tools import ToolLabelBinding, WorkflowToolProvider+from models.workflow import Workflowfrom services.agent.dsl_entities import AGENT_NODE_JOB_DSL_KEY, AGENT_PACKAGE_REF_KEY, AgentPackagefrom services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeErrorfrom services.agent.package_resource_exporter import AgentPackageResourceExporter@@ -35,23 +41,32 @@ from services.agent.roster_package_entities import (validate_icon_references,)from services.agent.roster_package_reader import RosterAgentPackageReader+from services.app_dsl_service import AppDslServicefrom services.dsl_content import DSL_MAX_SIZE-from services.entities.dsl_entities import DslImportWarning+from services.dsl_version import check_version_compatibility+from services.entities.dsl_entities import AppDslExportData, DslImportWarning, ImportStatus, PackagedWorkflowToolfrom services.entities.site_dsl import SiteDsl+from services.workflow_tool_references import iter_workflow_tool_references++_COPY_CHUNK_SIZE = 1024 * 1024_AGENT_ID_KEY = "agent_id"class AppPackageManifest(BaseModel):- """Index Agent resources by the same package references used in the workflow DSL."""+ """Index Agent resources by the same package references used in the workflow DSL.++ Version 2 also bundles the workflows the App calls through Workflow Tools; other packages stay version 1.+ """model_config = ConfigDict(extra="ignore")format: Literal["dify.app"]- format_version: Literal[1]+ format_version: Literal[1, 2]apps: list[RosterAgentPackageApp] = Field(min_length=1, max_length=1)agent_resources: dict[str, AgentPackageResources] = Field(default_factory=dict)icons: list[PackageIcon] = Field(default_factory=list)+ workflow_tools: list[PackagedWorkflowTool] = Field(default_factory=list)def iter_resources(self) -> Iterator[RosterAgentPackageSkill | RosterAgentPackageFile | PackageIcon]:yield from self.icons@@ -61,11 +76,15 @@ class AppPackageManifest(BaseModel):@model_validator(mode="after")def validate_resource_paths(self) -> Self:- resources = list(self.iter_resources())+ resources = [*self.iter_resources(), *self.workflow_tools]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")+ if len({tool.provider_id for tool in self.workflow_tools}) != len(self.workflow_tools):+ raise ValueError("App package workflow tools must have unique provider ids")+ if (self.format_version == 2) != bool(self.workflow_tools):+ raise ValueError("App package format version 2 is used exactly when workflow tools are bundled")return self@@ -74,6 +93,7 @@ class PreparedAppPackage(PreparedPackageArchive):dsl: stragents: dict[str, AgentPackage]agent_resources: dict[str, AgentPackageResources]+ workflow_tools: list[PackagedWorkflowTool]icons: list[PackageIcon] = field(default_factory=list)@property@@ -112,12 +132,57 @@ class PreparedAppPackage(PreparedPackageArchive):)return {ref: agent.model_dump(mode="json") for ref, agent in agents.items()}, warnings+ def open_workflow_tool(self, tool: PackagedWorkflowTool) -> PreparedAppPackage:+ return AppPackageService().read_workflow_tool(self, tool)+++@dataclass(frozen=True)+class _WorkflowToolExport:+ definition: dict[str, Any]+ package: RosterAgentPackageExport+class AppPackageService(RosterAgentPackageReader):"""Reuse the bounded ZIP reader; Apps retain DSL import semantics."""def read_package(self, source: BinaryIO, *, accept_roster_references: bool = False) -> PreparedAppPackage | None:"""Validate an App archive, or rewind a Roster package for its importer."""+ return self._read_package(source, bundled=False, accept_roster_references=accept_roster_references)++ def read_workflow_tool(self, package: PreparedPackageArchive, tool: PackagedWorkflowTool) -> PreparedAppPackage:+ """Validate the nested archive of a workflow called through a packaged Workflow Tool."""+ # The nested archive is validated, and later imported, from its own spooled copy.+ member = cast(BinaryIO, tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b")) # noqa: SIM115+ try:+ package.archive.seek(0)+ with zipfile.ZipFile(package.archive) as archive:+ digest = hashlib.sha256()+ size = 0+ with archive.open(archive.getinfo(tool.path)) as source:+ while chunk := source.read(_COPY_CHUNK_SIZE):+ size += len(chunk)+ if size > tool.size:+ raise InvalidRosterAgentPackageError("App package workflow tool failed integrity checks")+ digest.update(chunk)+ member.write(chunk)+ if size != tool.size or digest.hexdigest() != tool.sha256:+ raise InvalidRosterAgentPackageError("App package workflow tool failed integrity checks")+ member.seek(0)+ # Called workflows are always packaged with their own Agents, never roster links.+ nested = self._read_package(member, bundled=True, accept_roster_references=False)+ if nested is None:+ raise InvalidRosterAgentPackageError("App package workflow tool must be an App package")+ return nested+ except (KeyError, OSError, zipfile.BadZipFile, EOFError, RuntimeError, zlib.error) as exc:+ raise InvalidRosterAgentPackageError("App package workflow tool is not a valid ZIP") from exc+ finally:+ member.close()+ package.archive.seek(0)++ def _read_package(+ self, source: BinaryIO, *, bundled: bool, accept_roster_references: bool+ ) -> PreparedAppPackage | None:+ """Read an App archive; a ``bundled`` one is the workflow behind a packaged Workflow Tool."""spool = cast(BinaryIO, tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b")) # noqa: SIM115try:self._copy_bounded(source, spool)@@ -132,9 +197,19 @@ class AppPackageService(RosterAgentPackageReader):manifest = AppPackageManifest.model_validate(data)except ValidationError as exc:raise InvalidRosterAgentPackageError("App package manifest is invalid") from exc+ if bundled and manifest.workflow_tools:+ raise InvalidRosterAgentPackageError("App package workflow tools must not bundle workflow tools")+ if len(manifest.workflow_tools) > dify_config.APP_PACKAGE_MAX_WORKFLOW_TOOLS:+ raise RosterAgentPackageTooLargeError("App package bundles too many workflow tools")resource = manifest.apps[0]resources = list(manifest.iter_resources())- if set(infos) != {"manifest.yaml", resource.path, *(item.path for item in resources)}:+ expected_members = {+ "manifest.yaml",+ resource.path,+ *(item.path for item in resources),+ *(tool.path for tool in manifest.workflow_tools),+ }+ if set(infos) != expected_members: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@@ -145,8 +220,11 @@ class AppPackageService(RosterAgentPackageReader):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"}+ or (bundled and app_data["app"]["mode"] != AppMode.WORKFLOW)):raise InvalidRosterAgentPackageError("App package DSL is invalid")+ if bundled or manifest.workflow_tools:+ self._require_confirmed_version(app_data)agents = self._validate_agents(app_data, manifest, accept_roster_references=accept_roster_references)site_data = app_data.get("site")if site_data is not None:@@ -178,11 +256,12 @@ class AppPackageService(RosterAgentPackageReader):# Preserve the original text for version confirmation and legacy DSL handling.dsl = archive.read(resource.path).decode("utf-8")spool.seek(0)- return PreparedAppPackage(+ package = PreparedAppPackage(archive=spool,dsl=dsl,agents=agents,agent_resources=manifest.agent_resources,+ workflow_tools=manifest.workflow_tools,icons=manifest.icons,members=members,invalid_skills=invalid_skills,@@ -198,6 +277,36 @@ class AppPackageService(RosterAgentPackageReader):raisefinally:source.seek(0)+ try:+ self._validate_workflow_tools(package)+ except BaseException:+ package.close()+ raise+ return package++ def _validate_workflow_tools(self, package: PreparedAppPackage) -> None:+ # Each nested archive is bounded on its own; the App and every workflow it calls also share one limit.+ expanded_size = len(package.dsl.encode("utf-8")) + sum(member.size for member in package.members.values())+ for tool in package.workflow_tools:+ with self.read_workflow_tool(package, tool) as nested:+ expanded_size += len(nested.dsl.encode("utf-8")) + sum(+ member.size for member in nested.members.values()+ )+ if expanded_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError("App package and its workflow tools exceed the size limit")++ @staticmethod+ def _require_confirmed_version(app_data: dict[str, Any]) -> None:+ # Packages with workflow tools import every App at once, so none may wait for version confirmation.+ version = app_data.get("version") or "0.1.0"+ if not isinstance(version, str) or check_version_compatibility(version, CURRENT_APP_DSL_VERSION) in {+ ImportStatus.PENDING,+ ImportStatus.FAILED,+ }:+ raise InvalidRosterAgentPackageError(+ f"App package DSL version {version} needs confirmation, "+ "which is not supported for packages with workflow tools"+ )@classmethoddef _validate_agents(@@ -260,9 +369,34 @@ class AppPackageService(RosterAgentPackageReader):include_secret: bool = False,workflow_id: str | None = None,preserve_agent_bindings: bool = False,+ may_bundle: Callable[[App], bool],) -> RosterAgentPackageExport:- from services.app_dsl_service import AppDslService+ """Export an App with the workflows it calls; ``may_bundle`` admits each called workflow's App."""+ prepared, resources = self._prepare_export(+ app_model=app_model,+ include_secret=include_secret,+ workflow_id=workflow_id,+ preserve_agent_bindings=preserve_agent_bindings,+ )+ workflow_tools = self._export_workflow_tools(+ app_model=app_model, data=prepared.data, include_secret=include_secret, may_bundle=may_bundle+ )+ try:+ return self.export(+ dsl=AppDslService.serialize_export_data(prepared),+ name=app_model.name,+ resources=resources,+ accept_roster_references=preserve_agent_bindings,+ workflow_tools=workflow_tools,+ )+ finally:+ for workflow_tool in workflow_tools:+ workflow_tool.package.close()+ @staticmethod+ def _prepare_export(+ *, app_model: App, include_secret: bool, workflow_id: str | None, preserve_agent_bindings: bool+ ) -> tuple[AppDslExportData, AgentPackageResourceExporter]:resources = AgentPackageResourceExporter()with session_factory.create_session() as session:prepared = AppDslService.load_export_data(@@ -281,12 +415,106 @@ class AppPackageService(RosterAgentPackageReader):prepared.data["agent_packages"] = {ref: package.model_dump(mode="json") for ref, package in resources.packages.items()}- return self.export(- dsl=AppDslService.serialize_export_data(prepared),- name=app_model.name,- resources=resources,- accept_roster_references=preserve_agent_bindings,- )+ return prepared, resources++ def _export_workflow_tools(+ self, *, app_model: App, data: dict[str, Any], include_secret: bool, may_bundle: Callable[[App], bool]+ ) -> list[_WorkflowToolExport]:+ """Package every workflow reachable through Workflow Tools, at the version each tool runs.++ Workflows whose App the caller may not export stay plain references, and so do the workflows they call.+ """+ exports: list[_WorkflowToolExport] = []+ exported_size = 0+ visited: set[str] = set()+ pending = [data]+ try:+ while pending:+ provider_ids = {+ reference.provider_id for item in pending for reference in iter_workflow_tool_references(item)+ } - visited+ visited |= provider_ids+ pending = []+ for provider, app, workflow, labels in self._load_workflow_tools(+ tenant_id=app_model.tenant_id, provider_ids=provider_ids+ ):+ if not may_bundle(app):+ continue+ if len(exports) >= dify_config.APP_PACKAGE_MAX_WORKFLOW_TOOLS:+ raise RosterAgentPackageTooLargeError("App package calls too many workflow tools")+ prepared, resources = self._prepare_export(+ app_model=app,+ include_secret=include_secret,+ workflow_id=workflow.id,+ preserve_agent_bindings=False,+ )+ pending.append(prepared.data)+ package = self.export(+ dsl=AppDslService.serialize_export_data(prepared),+ name=app.name,+ resources=resources,+ workflow_tools=[],+ )+ exported_size += package.size+ # Stop before packaging further workflows that the final archive could not hold anyway.+ if exported_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ package.close()+ raise RosterAgentPackageTooLargeError("App package workflow tools exceed the size limit")+ exports.append(+ _WorkflowToolExport(+ definition={+ "provider_id": provider.id,+ "name": provider.name,+ "label": provider.label,+ "icon": emoji_icon_adapter.validate_json(provider.icon),+ "description": provider.description,+ "parameters": provider.parameter_configurations,+ "labels": labels,+ "privacy_policy": provider.privacy_policy or "",+ },+ package=package,+ )+ )+ except BaseException:+ for workflow_tool in exports:+ workflow_tool.package.close()+ raise+ return exports++ @staticmethod+ def _load_workflow_tools(+ *, tenant_id: str, provider_ids: set[str]+ ) -> list[tuple[WorkflowToolProvider, App, Workflow, list[str]]]:+ # Snippet-backed and unavailable tools have no workflow App here and stay plain references.+ if not provider_ids:+ return []+ with session_factory.create_session() as session:+ rows = session.execute(+ select(WorkflowToolProvider, App, Workflow)+ .join(App, (App.id == WorkflowToolProvider.app_id) & (App.tenant_id == tenant_id))+ .join(+ Workflow,+ (Workflow.app_id == WorkflowToolProvider.app_id)+ & (Workflow.version == WorkflowToolProvider.version)+ & (Workflow.tenant_id == tenant_id),+ )+ .where(+ WorkflowToolProvider.tenant_id == tenant_id,+ WorkflowToolProvider.id.in_(sorted(provider_ids)),+ App.mode == AppMode.WORKFLOW,+ Workflow.version != Workflow.VERSION_DRAFT,+ )+ .order_by(WorkflowToolProvider.id)+ ).all()+ labels: dict[str, list[str]] = {}+ for tool_id, label_name in session.execute(+ select(ToolLabelBinding.tool_id, ToolLabelBinding.label_name).where(+ ToolLabelBinding.tool_id.in_([provider.id for provider, _, _ in rows]),+ ToolLabelBinding.tool_type == ToolProviderType.WORKFLOW,+ )+ ):+ labels.setdefault(tool_id, []).append(label_name)+ return [(provider, app, workflow, labels.get(provider.id, [])) for provider, app, workflow in rows]def export(self,@@ -295,6 +523,7 @@ class AppPackageService(RosterAgentPackageReader):name: str,resources: AgentPackageResourceExporter | None = None,accept_roster_references: bool = False,+ workflow_tools: Sequence[_WorkflowToolExport],) -> RosterAgentPackageExport:payload = dsl.encode("utf-8")if len(payload) > DSL_MAX_SIZE:@@ -304,9 +533,13 @@ class AppPackageService(RosterAgentPackageReader):with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED) as package:agent_resources, total_size = resources.write_resources(package) if resources is not None else ({}, 0)icons, _ = resources.write_icons(package, total_size=total_size) if resources is not None else ([], 0)+ packaged_tools = [+ self._write_workflow_tool(package, workflow_tool, resource_id=f"w_{index:06d}")+ for index, workflow_tool in enumerate(workflow_tools, start=1)+ ]manifest = AppPackageManifest(format="dify.app",- format_version=1,+ format_version=2 if packaged_tools else 1,apps=[RosterAgentPackageApp(path="app.yaml", size=len(payload), sha256=hashlib.sha256(payload).hexdigest()@@ -314,6 +547,7 @@ class AppPackageService(RosterAgentPackageReader):],agent_resources=agent_resources,icons=icons,+ workflow_tools=packaged_tools,)package.writestr("manifest.yaml", yaml.safe_dump(manifest.model_dump(mode="json", exclude_defaults=True))@@ -331,3 +565,21 @@ class AppPackageService(RosterAgentPackageReader):except Exception:archive.close()raise++ @staticmethod+ def _write_workflow_tool(+ package: zipfile.ZipFile, workflow_tool: _WorkflowToolExport, *, resource_id: str+ ) -> PackagedWorkflowTool:+ path = f"{resource_id}.ifpkg"+ digest = hashlib.sha256()+ size = 0+ workflow_tool.package.archive.seek(0)+ # Nested archives are already compressed.+ with package.open(zipfile.ZipInfo(path), "w") as member:+ while chunk := workflow_tool.package.archive.read(_COPY_CHUNK_SIZE):+ size += len(chunk)+ digest.update(chunk)+ member.write(chunk)+ return PackagedWorkflowTool.model_validate(+ {**workflow_tool.definition, "id": resource_id, "path": path, "size": size, "sha256": digest.hexdigest()}+ )diff --git a/api/services/entities/dsl_entities.py b/api/services/entities/dsl_entities.pyindex fb97e7ee89a..9f21501b0fd 100644--- a/api/services/entities/dsl_entities.py+++ b/api/services/entities/dsl_entities.py@@ -1,12 +1,14 @@from dataclasses import dataclassfrom enum import StrEnum-from typing import Any, Protocol+from typing import Any, Protocol, Selffrom uuid import UUID-from pydantic import BaseModel, ConfigDict, Field+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validatorfrom constants.dsl_version import CURRENT_APP_DSL_VERSIONfrom core.plugin.entities.plugin import PluginDependency+from core.tools.entities.tool_entities import EmojiIconDict, WorkflowToolParameterConfiguration+from libs.helper import alphanumeric, uuid_valuefrom models.model import App, AppMode, IconType@@ -71,10 +73,50 @@ class DslImportWarning(BaseModel):details: dict[str, Any] = Field(default_factory=dict)+class PackagedWorkflowTool(BaseModel):+ """A workflow the packaged App calls through a Workflow Tool, stored as a nested single-App archive.++ ``provider_id`` is the tool's id in the exporting workspace, which the packaged DSLs still reference.+ """++ model_config = ConfigDict(extra="ignore")++ id: str = Field(pattern=r"^w_[0-9]{6}$")+ path: str+ size: int = Field(ge=0)+ sha256: str = Field(pattern=r"^[0-9a-f]{64}$")+ provider_id: str = Field(min_length=1, max_length=255)+ name: str = Field(min_length=1, max_length=255)+ label: str = Field(max_length=255)+ icon: EmojiIconDict+ description: str+ parameters: list[WorkflowToolParameterConfiguration]+ labels: list[str]+ privacy_policy: str++ @field_validator("provider_id")+ @classmethod+ def validate_provider_id(cls, value: str) -> str:+ uuid_value(value)+ return value++ @field_validator("name")+ @classmethod+ def validate_name(cls, value: str) -> str:+ return alphanumeric(value)++ @model_validator(mode="after")+ def validate_path(self) -> Self:+ if self.path != f"{self.id}.ifpkg":+ raise ValueError("workflow tool path must be the resource id with an .ifpkg extension")+ return self++class AppImportPackage(Protocol):"""Validated App archive used by import orchestration and resource materialization."""dsl: str+ workflow_tools: list[PackagedWorkflowTool]@propertydef has_resources(self) -> bool: ...@@ -85,6 +127,8 @@ class AppImportPackage(Protocol):self, *, tenant_id: str, account_id: str) -> tuple[dict[str, Any], list[DslImportWarning]]: ...+ def open_workflow_tool(self, tool: PackagedWorkflowTool) -> "AppImportPackage": ...+def close(self) -> None: ...diff --git a/api/services/workflow_tool_references.py b/api/services/workflow_tool_references.pynew file mode 100644index 00000000000..d9c56282628--- /dev/null+++ b/api/services/workflow_tool_references.py@@ -0,0 +1,81 @@+"""Locate and retarget Workflow Tool references inside App DSL data."""++from collections.abc import Iterator, Mapping+from dataclasses import dataclass+from typing import Any++import yaml++from graphon.enums import BuiltinNodeTypes+from graphon.nodes.tool.entities import ToolProviderType+++@dataclass(frozen=True)+class WorkflowToolReference:+ """A tool configuration in a DSL whose ``id_key`` holds a Workflow Tool provider id."""++ config: dict[str, Any]+ id_key: str++ @property+ def provider_id(self) -> str:+ return self.config[self.id_key]+++@dataclass(frozen=True)+class WorkflowToolTarget:+ """The Workflow Tool that a packaged provider id resolves to in the importing workspace."""++ provider_id: str+ name: str+ create: bool+++def iter_workflow_tool_references(data: Mapping[str, Any]) -> Iterator[WorkflowToolReference]:+ """Yield the Workflow Tool references of tool nodes, legacy Agent nodes and agent-chat configs."""+ tool_configs: list[Any] = []+ workflow = data.get("workflow")+ graph = workflow.get("graph") if isinstance(workflow, Mapping) else None+ nodes = graph.get("nodes") if isinstance(graph, Mapping) else None+ for node in nodes if isinstance(nodes, list) else []:+ node_data = node.get("data") if isinstance(node, Mapping) else None+ if not isinstance(node_data, Mapping):+ continue+ if node_data.get("type") == BuiltinNodeTypes.TOOL:+ tool_configs.append(node_data)+ agent_parameters = node_data.get("agent_parameters")+ if node_data.get("type") == BuiltinNodeTypes.AGENT and isinstance(agent_parameters, Mapping):+ for parameter in agent_parameters.values():+ value = parameter.get("value") if isinstance(parameter, Mapping) else None+ tool_configs.extend(value if isinstance(value, list) else [])+ model_config = data.get("model_config")+ agent_mode = model_config.get("agent_mode") if isinstance(model_config, Mapping) else None+ agent_tools = agent_mode.get("tools") if isinstance(agent_mode, Mapping) else None+ tool_configs.extend(agent_tools if isinstance(agent_tools, list) else [])++ for config in tool_configs:+ if not isinstance(config, dict):+ continue+ # Agent node tools name the provider type ``type`` and keep the provider id in ``provider_name``.+ if "provider_type" in config:+ provider_type, id_key = config["provider_type"], "provider_id"+ else:+ provider_type, id_key = config.get("type"), "provider_name"+ provider_id = config.get(id_key)+ if provider_type == ToolProviderType.WORKFLOW and isinstance(provider_id, str) and provider_id:+ yield WorkflowToolReference(config=config, id_key=id_key)+++def retarget_workflow_tool_dsl(dsl: str, targets: Mapping[str, WorkflowToolTarget]) -> str:+ """Point the DSL's Workflow Tool references at their targets, keeping unknown providers as they are."""+ data = yaml.safe_load(dsl)+ if not isinstance(data, dict):+ return dsl+ for reference in iter_workflow_tool_references(data):+ target = targets.get(reference.provider_id)+ if target is None:+ continue+ reference.config[reference.id_key] = target.provider_id+ # The editor matches a tool node's outputs by the tool name, which follows a renamed provider.+ reference.config["tool_name"] = target.name+ return yaml.dump(data, allow_unicode=True)diff --git a/api/tests/e2e_tests/containers/services/test_app_dsl_service.py b/api/tests/e2e_tests/containers/services/test_app_dsl_service.pyindex 0ecfc528a00..2e9ed423484 100644--- a/api/tests/e2e_tests/containers/services/test_app_dsl_service.py+++ b/api/tests/e2e_tests/containers/services/test_app_dsl_service.py@@ -1496,11 +1496,6 @@ class TestAppDslService:lambda provider: f"model:{provider}",)- monkeypatch.setattr(- app_dsl_service.ToolNodeData,- "model_validate",- lambda _d: SimpleNamespace(provider_id="p1"),- )monkeypatch.setattr(app_dsl_service.LLMNodeData,"model_validate",@@ -1536,7 +1531,19 @@ class TestAppDslService:graph = {"nodes": [- {"data": {"type": BuiltinNodeTypes.TOOL}},+ {+ "data": {+ "type": BuiltinNodeTypes.TOOL,+ "title": "Tool",+ "provider_id": "p1",+ "provider_type": "builtin",+ "provider_name": "p1",+ "tool_name": "run",+ "tool_label": "Run",+ "tool_configurations": {},+ "tool_parameters": {},+ }+ },{"data": {"type": BuiltinNodeTypes.LLM}},{"data": {"type": BuiltinNodeTypes.QUESTION_CLASSIFIER}},{"data": {"type": BuiltinNodeTypes.PARAMETER_EXTRACTOR}},@@ -1583,7 +1590,7 @@ class TestAppDslService:"dataset_configs": {"datasets": {"datasets": [{"reranking_model": {"reranking_provider_name": {"provider": "p2"}}}]}},- "agent_mode": {"tools": [{"provider_id": "t1"}]},+ "agent_mode": {"tools": [{"provider_type": "builtin", "provider_id": "t1"}]},})assert deps == ["model:p1", "model:p2", "tool:t1"]diff --git a/api/tests/unit_tests/controllers/console/app/test_app_import.py b/api/tests/unit_tests/controllers/console/app/test_app_import.pyindex e6759518c1f..4f4ec5fa5b9 100644--- a/api/tests/unit_tests/controllers/console/app/test_app_import.py+++ b/api/tests/unit_tests/controllers/console/app/test_app_import.py@@ -562,7 +562,7 @@ class TestRosterPackageRoutesCases:) -> None:imports.status = statusdsl = "kind: app\nversion: 99.0.0\napp:\n mode: workflow\n"- with AppPackageService().export(dsl=dsl, name="Workflow") as package:+ with AppPackageService().export(dsl=dsl, name="Workflow", workflow_tools=[]) as package:form: dict[str, object] = {"file": (package.archive, "workflow.ifpkg"), "name": "Renamed"}if app_id:form["app_id"] = app_id@@ -606,7 +606,9 @@ class TestRosterPackageRoutesCases:lambda app_id, access_mode: access_updates.append((app_id, access_mode)),)app_id = "app-1" if overwrite else None- with AppPackageService().export(dsl="kind: app\napp:\n mode: workflow\n", name="Workflow") as package:+ with AppPackageService().export(+ dsl="kind: app\napp:\n mode: workflow\n", name="Workflow", workflow_tools=[]+ ) as package:if from_url:_mock_download(monkeypatch, package.archive.read())_data, code = _post(@@ -799,7 +801,9 @@ class TestRosterPackageRoutesCases:)features = FeatureModel(apps=LimitationModel(size=1, limit=1))monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", lambda *_a, **_k: features)- with AppPackageService().export(dsl="kind: app\napp: {mode: workflow}\n", name="Workflow") as package:+ with AppPackageService().export(+ dsl="kind: app\napp: {mode: workflow}\n", name="Workflow", workflow_tools=[]+ ) as package:with pytest.raises(Forbidden):_post(app, imports, data={"file": (package.archive, "workflow.ifpkg")})assert imports.dsl_calls == []diff --git a/api/tests/unit_tests/services/app/test_console_gateway.py b/api/tests/unit_tests/services/app/test_console_gateway.pyindex 5c5e005c8bb..a49df5e453f 100644--- a/api/tests/unit_tests/services/app/test_console_gateway.py+++ b/api/tests/unit_tests/services/app/test_console_gateway.py@@ -715,7 +715,7 @@ def test_console_package_import_forwards_archive_and_closes_it(return Import(id="import-1", status=status)monkeypatch.setattr(AppDslService, "import_app", import_app)- with AppPackageService().export(dsl=dsl, name="Example") as exported:+ with AppPackageService().export(dsl=dsl, name="Example", workflow_tools=[]) as exported:result = app_services.console.import_app(context, AppImportParams(mode="yaml-content"), source=exported.archive)assert result.status == statusassert len(archives) == 1diff --git a/api/tests/unit_tests/services/app/test_console_service.py b/api/tests/unit_tests/services/app/test_console_service.pyindex 440d360ae76..3f05836f1c1 100644--- a/api/tests/unit_tests/services/app/test_console_service.py+++ b/api/tests/unit_tests/services/app/test_console_service.py@@ -1,23 +1,34 @@"""Console use cases exercise ports without a request or an ORM session."""+import base64import json-from collections.abc import Sequence+import os+from collections.abc import Callable, Sequencefrom contextlib import AbstractContextManagerfrom dataclasses import dataclass, field, replacefrom datetime import datetimefrom io import BytesIOfrom typing import BinaryIO, Literal, cast, overridefrom uuid import UUID, uuid4+from zipfile import ZipFileimport pytest+import yaml+from blinker import Signalfrom sqlalchemy import Engine, event, func, selectfrom sqlalchemy.orm import Session, sessionmaker+from core.plugin.entities.plugin import PluginDependencyfrom core.plugin.impl.plugin import PluginInstaller-from core.tools.entities.tool_entities import ApiProviderSchemaType+from core.rbac import RBACPermission+from core.tools.entities.tool_entities import ApiProviderSchemaType, ToolProviderTypefrom core.tools.tool_manager import ToolManagerfrom events.app_event import app_was_updated+from extensions.application_services.app import AppServices+from extensions.ext_database import db+from extensions.ext_redis import redis_clientfrom graphon.model_runtime.entities.model_entities import ModelType+from libs.datetime_utils import naive_utc_nowfrom machinery.context import RequestContextfrom models.account import Account, Tenant, TenantAccountJoin, TenantAccountRolefrom models.agent import Agent, AgentConfigSnapshot, AgentStatus@@ -25,12 +36,20 @@ from models.agent_config_entities import AgentSoulConfigfrom models.model import App, AppMode, AppModelConfig, IconType, InstalledApp, Sitefrom models.provider import TenantDefaultModelfrom models.provider_ids import GenericProviderID-from models.tools import ApiToolProvider+from models.tools import ApiToolProvider, ToolLabelBinding, WorkflowToolProvider+from models.workflow import Workflow, WorkflowTypefrom repositories.app.console_repository import ConsoleAppRepository-from services.agent.errors import AgentAccessNotReadyError+from repositories.recommended_app_catalog_repository import DatabaseRecommendedAppCatalogRepository+from services.agent.errors import (+ AgentAccessNotReadyError,+ InvalidRosterAgentPackageError,+ RosterAgentPackageTooLargeError,+)from services.agent.roster_package_entities import RosterAgentPackageExport+from services.agent.roster_package_exporter import RosterAgentPackageExporter+from services.agent.roster_package_importer import RosterAgentPackageImporterfrom services.agent.roster_service import AgentRosterService-from services.app.console_gateway import AppLifecycleGateway+from services.app.console_gateway import AppLifecycleGateway, AppTransferGatewayfrom services.app.console_service import (AppExportPaidPlanRequiredError,ConsoleAppNotFoundError,@@ -39,6 +58,8 @@ from services.app.console_service import (CreatorsPlatformDisabledError,InvalidAppExportError,)+from services.app_dsl_service import AppDslService+from services.app_package_service import AppPackageServicefrom services.app_tracing_config_service import AppTraceSettingsfrom services.entities.app_entities import (AppCreationSettings,@@ -61,8 +82,18 @@ from services.entities.dsl_entities import (CheckDependenciesResult,Import,ImportStatus,+ PackagedWorkflowTool,)+from services.entities.feature_entities import FeatureModel, LimitationModel+from services.errors.base import NoPermissionError+from services.feature_service import FeatureServicefrom services.model_provider.service import ModelProviderService+from services.plugin.dependencies_analysis import DependenciesAnalysisService+from services.recommended_app_package_service import RecommendedAppPackageService+from services.workflow_tool_references import WorkflowToolTarget+from tasks.remove_app_and_related_data_task import remove_app_and_related_data_task+from tests.helpers.unit.model_factories import make_account, make_tenant+from tests.helpers.unit.rbac_fakes import RBACDomainCONTEXT = RequestContext("request", "trace", "actor", "workspace")RECORD = AppRecord(id="app", name="Example", mode_compatible_with_agent="chat")@@ -194,6 +225,18 @@ class Transfers:del context, app_idpytest.fail("Unexpected dependency check")+ def plan_workflow_tools(+ self, context: RequestContext, tools: Sequence[PackagedWorkflowTool], *, creates_root_app: bool+ ) -> dict[str, WorkflowToolTarget]:+ del context, tools, creates_root_app+ pytest.fail("Unexpected workflow tool planning")++ def create_workflow_tool(+ self, context: RequestContext, *, app_id: str, tool: PackagedWorkflowTool, target: WorkflowToolTarget+ ) -> None:+ del context, app_id, tool, target+ pytest.fail("Unexpected workflow tool creation")+def import_dsl(self,context: RequestContext,@@ -1031,3 +1074,566 @@ def test_unpublished_agent_cannot_enable_access_through_console_service(sqlite_eassert not persisted.enable_apifinally:app_was_updated.disconnect(updated)+++_TOOL_NAME = "summarize"+++@dataclass(frozen=True)+class Workspaces:+ source: RequestContext+ target: RequestContext+ caller_app_id: str+ tool_app_id: str+ provider_id: str+++def _no_plugin_dependencies(*, tenant_id: str, dependencies: list[str]) -> list[PluginDependency]:+ del tenant_id+ assert dependencies == []+ return []+++def _features_with_one_free_app(tenant_id: str, *, exclude_vector_space: bool) -> FeatureModel:+ del tenant_id, exclude_vector_space+ return FeatureModel(apps=LimitationModel(size=4, limit=5))+++def _workflow(*, tenant_id: str, app_id: str, version: str, graph: dict[str, object], created_by: str) -> Workflow:+ return Workflow(+ id=str(uuid4()),+ tenant_id=tenant_id,+ app_id=app_id,+ type=WorkflowType.WORKFLOW,+ version=version,+ graph=json.dumps(graph),+ _features=json.dumps({}),+ _environment_variables=[],+ _conversation_variables=[],+ created_by=created_by,+ )+++def _workflow_tool(+ *, provider_id: str, tenant_id: str, app_id: str, version: str, user_id: str+) -> WorkflowToolProvider:+ provider = WorkflowToolProvider(+ name=_TOOL_NAME,+ label="Summarize",+ icon=json.dumps({"background": "#FFEAD5", "content": "🤖"}),+ app_id=app_id,+ version=version,+ user_id=user_id,+ tenant_id=tenant_id,+ description="Summarize a document",+ parameter_configuration="[]",+ )+ provider.id = provider_id+ return provider+++def _tool_node(provider_id: str, tool_name: str) -> dict[str, object]:+ return {+ "id": tool_name,+ "data": {+ "type": "tool",+ "title": tool_name,+ "provider_id": provider_id,+ "provider_type": "workflow",+ "provider_name": tool_name,+ "tool_name": tool_name,+ "tool_label": tool_name,+ "tool_configurations": dict[str, object](),+ "tool_parameters": dict[str, object](),+ },+ }+++def workspaces(+ sqlite_session_factory: sessionmaker[Session],+ sqlite_engine: Engine,+ monkeypatch: pytest.MonkeyPatch,+ config_overrides: Callable[..., None],+) -> Workspaces:+ config_overrides(RBAC_ENABLED=False, DEPLOYMENT_EDITION="COMMUNITY")+ # Workflow Tool management opens its own sessions from the Flask-SQLAlchemy engine.+ monkeypatch.setattr(type(db), "engine", property(lambda _: sqlite_engine))+ # Plugin metadata is resolved by the plugin daemon; these Apps use no plugins.+ monkeypatch.setattr(DependenciesAnalysisService, "generate_dependencies", _no_plugin_dependencies)+ # Workflow event handlers reach the Flask-bound database; these tests check the imported records.+ monkeypatch.setattr("services.workflow_service.app_draft_workflow_was_synced", Signal())+ monkeypatch.setattr("services.workflow_service.app_published_workflow_was_updated", Signal())+ actor, source_id, target_id = str(uuid4()), str(uuid4()), str(uuid4())+ caller_app_id, tool_app_id, provider_id = str(uuid4()), str(uuid4()), str(uuid4())+ version = Workflow.version_from_datetime(naive_utc_now())+ published = _workflow(+ tenant_id=source_id,+ app_id=tool_app_id,+ version=version,+ graph={"nodes": list[object](), "edges": list[object]()},+ created_by=actor,+ )+ caller_graph: dict[str, object] = {"nodes": [_tool_node(provider_id, _TOOL_NAME)], "edges": list[object]()}+ with sqlite_session_factory.begin() as session:+ session.add_all(+ [+ make_account(account_id=actor, name="Creator", email=f"{actor}@example.com"),+ make_tenant(tenant_id=source_id, name="Source"),+ make_tenant(tenant_id=target_id, name="Target"),+ TenantAccountJoin(tenant_id=source_id, account_id=actor, role=TenantAccountRole.OWNER),+ TenantAccountJoin(tenant_id=target_id, account_id=actor, role=TenantAccountRole.OWNER),+ App(+ id=tool_app_id,+ tenant_id=source_id,+ name="Summarizer",+ mode=AppMode.WORKFLOW,+ enable_site=True,+ enable_api=True,+ workflow_id=published.id,+ ),+ published,+ _workflow_tool(+ provider_id=provider_id, tenant_id=source_id, app_id=tool_app_id, version=version, user_id=actor+ ),+ ToolLabelBinding(tool_id=provider_id, tool_type=ToolProviderType.WORKFLOW, label_name="productivity"),+ App(+ id=caller_app_id,+ tenant_id=source_id,+ name="Caller",+ mode=AppMode.WORKFLOW,+ enable_site=True,+ enable_api=True,+ ),+ _workflow(+ tenant_id=source_id,+ app_id=caller_app_id,+ version=Workflow.VERSION_DRAFT,+ graph=caller_graph,+ created_by=actor,+ ),+ ]+ )+ return Workspaces(+ source=RequestContext("request", None, actor, source_id),+ target=RequestContext("request", None, actor, target_id),+ caller_app_id=caller_app_id,+ tool_app_id=tool_app_id,+ provider_id=provider_id,+ )+++def _export_and_import(+ app_services: AppServices, workspaces: Workspaces, context: RequestContext, params: AppImportParams+) -> Import:+ exported = app_services.console.export(workspaces.source, workspaces.caller_app_id, AppExportOptions())+ assert not isinstance(exported, str)+ with exported:+ return app_services.console.import_app(context, params, source=exported.archive)+++def _caller_tool_node(session: Session, app_id: str) -> dict[str, object]:+ draft = session.scalar(+ select(Workflow).where(Workflow.app_id == app_id, Workflow.version == Workflow.VERSION_DRAFT)+ )+ assert draft is not None+ [node] = draft.graph_dict["nodes"]+ return node["data"]+++def _call_ranker_from_summarizer(+ sqlite_session_factory: sessionmaker[Session], workspaces: Workspaces, ranker_nodes: list[dict[str, object]]+) -> str:+ """Make the summarizer call a second Workflow Tool, ``rank``, whose published workflow runs ``ranker_nodes``."""+ source_id, actor = workspaces.source.active_workspace_id, workspaces.source.account_id+ ranker_app_id, ranker_provider_id = str(uuid4()), str(uuid4())+ version = Workflow.version_from_datetime(naive_utc_now())+ ranker_workflow = _workflow(+ tenant_id=source_id,+ app_id=ranker_app_id,+ version=version,+ graph={"nodes": ranker_nodes, "edges": list[object]()},+ created_by=actor,+ )+ ranker = _workflow_tool(+ provider_id=ranker_provider_id, tenant_id=source_id, app_id=ranker_app_id, version=version, user_id=actor+ )+ ranker.name = "rank"+ with sqlite_session_factory.begin() as session:+ session.add_all(+ [+ App(+ id=ranker_app_id,+ tenant_id=source_id,+ name="Ranker",+ mode=AppMode.WORKFLOW,+ enable_site=True,+ enable_api=True,+ workflow_id=ranker_workflow.id,+ ),+ ranker_workflow,+ ranker,+ ]+ )+ summarizer = session.scalar(+ select(Workflow).where(+ Workflow.app_id == workspaces.tool_app_id, Workflow.version != Workflow.VERSION_DRAFT+ )+ )+ assert summarizer is not None+ summarizer.graph = json.dumps({"nodes": [_tool_node(ranker_provider_id, "rank")], "edges": list[object]()})+ return ranker_provider_id+++def test_export_bundles_the_pinned_workflow_and_its_tool_definition(+ app_services: AppServices, workspaces: Workspaces+) -> None:+ exported = app_services.console.export(workspaces.source, workspaces.caller_app_id, AppExportOptions())+ assert not isinstance(exported, str)+ with exported, ZipFile(exported.archive) as archive:+ manifest = yaml.safe_load(archive.read("manifest.yaml"))+ assert manifest["format_version"] == 2+ [tool] = manifest["workflow_tools"]+ assert (tool["provider_id"], tool["name"], tool["labels"]) == (+ workspaces.provider_id,+ _TOOL_NAME,+ ["productivity"],+ )+ with ZipFile(archive.open(tool["path"])) as nested:+ assert yaml.safe_load(nested.read("app.yaml"))["app"]["name"] == "Summarizer"+++ ("maintained_by_caller", "allowed", "bundled"),+ [(False, False, False), (False, True, True), (True, False, True)],+ ids=["denied", "allowed", "maintainer"],+)+def test_export_bundles_only_workflows_the_caller_may_export(+ app_services: AppServices,+ workspaces: Workspaces,+ sqlite_session_factory: sessionmaker[Session],+ rbac_domain: RBACDomain,+ config_overrides: Callable[..., None],+ maintained_by_caller: bool,+ allowed: bool,+ bundled: bool,+) -> None:+ config_overrides(RBAC_ENABLED=True)+ rbac_domain.transport.response = {"allowed": allowed}+ if maintained_by_caller:+ with sqlite_session_factory.begin() as session:+ tool_app = session.get(App, workspaces.tool_app_id)+ assert tool_app is not None+ tool_app.maintainer = workspaces.source.account_id++ exported = app_services.console.export(workspaces.source, workspaces.caller_app_id, AppExportOptions())++ assert not isinstance(exported, str)+ with exported, ZipFile(exported.archive) as archive:+ manifest = yaml.safe_load(archive.read("manifest.yaml"))+ dsl = yaml.safe_load(archive.read("app.yaml"))+ assert [tool["provider_id"] for tool in manifest.get("workflow_tools", [])] == (+ [workspaces.provider_id] if bundled else []+ )+ # A workflow that is not bundled stays a plain reference, as exports were before packages carried workflows.+ assert dsl["workflow"]["graph"]["nodes"][0]["data"]["provider_id"] == workspaces.provider_id+ checked_apps = [request.json["resource_id"] for request in rbac_domain.transport.requests if request.json]+ assert checked_apps == ([] if maintained_by_caller else [workspaces.tool_app_id])+++def test_import_into_another_workspace_recreates_the_called_workflow_as_a_tool(+ app_services: AppServices, workspaces: Workspaces, sqlite_session_factory: sessionmaker[Session]+) -> None:+ result = _export_and_import(app_services, workspaces, workspaces.target, AppImportParams(mode="yaml-content"))++ assert result.status == ImportStatus.COMPLETED+ target_id = workspaces.target.active_workspace_id+ with sqlite_session_factory() as session:+ [provider] = session.scalars(select(WorkflowToolProvider).where(WorkflowToolProvider.tenant_id == target_id))+ assert provider.id != workspaces.provider_id+ assert provider.name == _TOOL_NAME+ tool_app = session.get(App, provider.app_id)+ assert tool_app is not None+ assert (tool_app.tenant_id, tool_app.name) == (target_id, "Summarizer")+ published = session.get(Workflow, tool_app.workflow_id)+ assert published is not None+ assert published.version == provider.version+ assert list(session.scalars(select(ToolLabelBinding.label_name).where(ToolLabelBinding.tool_id == provider.id)))+ assert _caller_tool_node(session, str(result.app_id))["provider_id"] == provider.id+ assert {app.id for app in session.scalars(select(App).where(App.tenant_id == target_id))} == {+ tool_app.id,+ result.app_id,+ }+++def test_import_into_the_same_workspace_reuses_the_existing_tool(+ app_services: AppServices, workspaces: Workspaces, sqlite_session_factory: sessionmaker[Session]+) -> None:+ result = _export_and_import(app_services, workspaces, workspaces.source, AppImportParams(mode="yaml-content"))++ assert result.status == ImportStatus.COMPLETED+ source_id = workspaces.source.active_workspace_id+ with sqlite_session_factory() as session:+ providers = session.scalars(select(WorkflowToolProvider.id).where(WorkflowToolProvider.tenant_id == source_id))+ assert list(providers) == [workspaces.provider_id]+ assert session.scalar(select(App.id).where(App.id == result.app_id)) is not None+ assert len(list(session.scalars(select(App.id).where(App.tenant_id == source_id)))) == 3+ assert _caller_tool_node(session, str(result.app_id))["provider_id"] == workspaces.provider_id+++def test_import_renames_a_tool_whose_name_is_taken(+ app_services: AppServices, workspaces: Workspaces, sqlite_session_factory: sessionmaker[Session]+) -> None:+ target_id = workspaces.target.active_workspace_id+ taken_app_id = str(uuid4())+ with sqlite_session_factory.begin() as session:+ session.add_all(+ [+ App(+ id=taken_app_id,+ tenant_id=target_id,+ name="Taken",+ mode=AppMode.WORKFLOW,+ enable_site=True,+ enable_api=True,+ ),+ _workflow_tool(+ provider_id=str(uuid4()),+ tenant_id=target_id,+ app_id=taken_app_id,+ version="1",+ user_id=workspaces.target.account_id,+ ),+ ]+ )++ result = _export_and_import(app_services, workspaces, workspaces.target, AppImportParams(mode="yaml-content"))++ assert result.status == ImportStatus.COMPLETED+ with sqlite_session_factory() as session:+ provider = session.scalar(+ select(WorkflowToolProvider).where(+ WorkflowToolProvider.tenant_id == target_id, WorkflowToolProvider.app_id != taken_app_id+ )+ )+ assert provider is not None+ assert provider.name == f"{_TOOL_NAME}_2"+ node = _caller_tool_node(session, str(result.app_id))+ assert (node["provider_id"], node["tool_name"]) == (provider.id, f"{_TOOL_NAME}_2")+++def test_import_requires_permission_to_create_tools_before_creating_anything(+ app_services: AppServices, workspaces: Workspaces, sqlite_session_factory: sessionmaker[Session]+) -> None:+ target_id = workspaces.target.active_workspace_id+ with sqlite_session_factory.begin() as session:+ join = session.scalar(select(TenantAccountJoin).where(TenantAccountJoin.tenant_id == target_id))+ assert join is not None+ join.role = TenantAccountRole.EDITOR++ with pytest.raises(NoPermissionError, match="workflow tools"):+ _export_and_import(app_services, workspaces, workspaces.target, AppImportParams(mode="yaml-content"))++ with sqlite_session_factory() as session:+ assert list(session.scalars(select(App.id).where(App.tenant_id == target_id))) == []++[email protected]("broker_available", [True, False])+def test_failed_import_deletes_the_workflows_it_created(+ app_services: AppServices,+ workspaces: Workspaces,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+ caplog: pytest.LogCaptureFixture,+ broker_available: bool,+) -> None:+ cleanups: list[dict[str, str]] = []++ def enqueue_cleanup(**kwargs: str) -> None:+ cleanups.append(kwargs)+ if not broker_available:+ raise ConnectionError("The message broker is unavailable")++ monkeypatch.setattr(remove_app_and_related_data_task, "delay", enqueue_cleanup)+ monkeypatch.setattr("services.app_service.app_was_deleted", Signal())+ target_id = workspaces.target.active_workspace_id++ result = _export_and_import(+ app_services, workspaces, workspaces.target, AppImportParams(mode="yaml-content", app_id=str(uuid4()))+ )++ assert result.status == ImportStatus.FAILED+ [cleanup] = cleanups+ assert cleanup["tenant_id"] == target_id+ assert ("left by a failed package import" in caplog.text) is not broker_available+ with sqlite_session_factory() as session:+ assert list(session.scalars(select(App.id).where(App.tenant_id == target_id))) == []+++def test_import_recreates_workflows_that_call_each_other(+ app_services: AppServices, workspaces: Workspaces, sqlite_session_factory: sessionmaker[Session]+) -> None:+ _call_ranker_from_summarizer(sqlite_session_factory, workspaces, [_tool_node(workspaces.provider_id, _TOOL_NAME)])++ result = _export_and_import(app_services, workspaces, workspaces.target, AppImportParams(mode="yaml-content"))++ assert result.status == ImportStatus.COMPLETED+ target_id = workspaces.target.active_workspace_id+ with sqlite_session_factory() as session:+ providers = {+ provider.name: provider+ for provider in session.scalars(+ select(WorkflowToolProvider).where(WorkflowToolProvider.tenant_id == target_id)+ )+ }+ assert set(providers) == {_TOOL_NAME, "rank"}+ for name, called in ((_TOOL_NAME, "rank"), ("rank", _TOOL_NAME)):+ published = session.scalar(+ select(Workflow).where(+ Workflow.app_id == providers[name].app_id, Workflow.version == providers[name].version+ )+ )+ assert published is not None+ [node] = published.graph_dict["nodes"]+ assert node["data"]["provider_id"] == providers[called].id+++def test_import_checks_the_quota_for_every_app_it_creates(+ app_services: AppServices,+ workspaces: Workspaces,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+ config_overrides: Callable[..., None],+) -> None:+ exported = app_services.console.export(workspaces.source, workspaces.caller_app_id, AppExportOptions())+ assert not isinstance(exported, str)+ config_overrides(DEPLOYMENT_EDITION="CLOUD")+ # Billing limits come from the billing service; one App slot is left for a package that needs two.+ monkeypatch.setattr(FeatureService, "get_features", _features_with_one_free_app)++ with exported, pytest.raises(NoPermissionError, match="limit"):+ app_services.console.import_app(+ workspaces.target, AppImportParams(mode="yaml-content"), source=exported.archive+ )++ target_id = workspaces.target.active_workspace_id+ with sqlite_session_factory() as session:+ assert list(session.scalars(select(App.id).where(App.tenant_id == target_id))) == []+++ ("knowledge_node", "error", "created_apps"),+ [+ ({}, "'rank' could not be imported", 1),+ ({"query_variable_selector": ["start", "query"]}, "'rank' could not be created", 2),+ ],+ ids=["invalid-node", "missing-knowledge-base"],+)+def test_import_deletes_created_workflows_when_a_called_workflow_fails(+ app_services: AppServices,+ workspaces: Workspaces,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+ knowledge_node: dict[str, object],+ error: str,+ created_apps: int,+) -> None:+ knowledge: dict[str, object] = {+ "id": "knowledge",+ "data": {+ "type": "knowledge-retrieval-v2",+ "title": "Knowledge",+ "control_space_ids": [str(uuid4())],+ **knowledge_node,+ },+ }+ _call_ranker_from_summarizer(sqlite_session_factory, workspaces, [knowledge])+ cleanups: list[dict[str, str]] = []+ monkeypatch.setattr(remove_app_and_related_data_task, "delay", lambda **kwargs: cleanups.append(kwargs))+ monkeypatch.setattr("services.app_service.app_was_deleted", Signal())++ with pytest.raises(InvalidRosterAgentPackageError, match=error):+ _export_and_import(app_services, workspaces, workspaces.target, AppImportParams(mode="yaml-content"))++ target_id = workspaces.target.active_workspace_id+ assert len(cleanups) == created_apps+ with sqlite_session_factory() as session:+ assert list(session.scalars(select(App.id).where(App.tenant_id == target_id))) == []+++def test_export_stops_at_the_workflow_tool_limit(+ app_services: AppServices,+ workspaces: Workspaces,+ sqlite_session_factory: sessionmaker[Session],+ config_overrides: Callable[..., None],+) -> None:+ _call_ranker_from_summarizer(sqlite_session_factory, workspaces, [])+ config_overrides(APP_PACKAGE_MAX_WORKFLOW_TOOLS=1)++ with pytest.raises(RosterAgentPackageTooLargeError, match="too many workflow tools"):+ app_services.console.export(workspaces.source, workspaces.caller_app_id, AppExportOptions())+++def test_export_stops_once_the_workflow_tools_outgrow_the_package_limit(+ app_services: AppServices,+ workspaces: Workspaces,+ sqlite_session_factory: sessionmaker[Session],+ config_overrides: Callable[..., None],+) -> None:+ _call_ranker_from_summarizer(sqlite_session_factory, workspaces, [])+ with sqlite_session_factory.begin() as session:+ for app in session.scalars(select(App).where(App.id != workspaces.caller_app_id)):+ # Random data keeps each packaged workflow near its uncompressed size.+ app.description = base64.b64encode(os.urandom(180_000)).decode()+ # Each workflow fits on its own; the two together do not.+ config_overrides(AGENT_PACKAGE_MAX_BYTES=300_000)++ with pytest.raises(RosterAgentPackageTooLargeError, match="App package workflow tools exceed"):+ app_services.console.export(workspaces.source, workspaces.caller_app_id, AppExportOptions())++[email protected]("allowed", [True, False])+def test_planning_new_workflow_tools_checks_tool_management_under_rbac(+ workspaces: Workspaces,+ sqlite_session_factory: sessionmaker[Session],+ rbac_domain: RBACDomain,+ config_overrides: Callable[..., None],+ allowed: bool,+) -> None:+ config_overrides(RBAC_ENABLED=True)+ rbac_domain.transport.response = {"allowed": allowed}+ gateway = AppTransferGateway(+ session_factory=sqlite_session_factory,+ dsl_factory=AppDslService,+ packages=AppPackageService(),+ agent_packages=RosterAgentPackageExporter(),+ agent_importer=RosterAgentPackageImporter(),+ recommended_packages=RecommendedAppPackageService(+ sources=DatabaseRecommendedAppCatalogRepository(session_factory=sqlite_session_factory, redis=redis_client),+ exporter=RosterAgentPackageExporter(),+ ),+ )+ tool = PackagedWorkflowTool(+ id="w_000001",+ path="w_000001.ifpkg",+ size=0,+ sha256="0" * 64,+ provider_id=workspaces.provider_id,+ name=_TOOL_NAME,+ label="Summarize",+ icon={"background": "#FFEAD5", "content": "🤖"},+ description="",+ parameters=[],+ labels=[],+ privacy_policy="",+ )++ if allowed:+ targets = gateway.plan_workflow_tools(workspaces.target, [tool], creates_root_app=True)+ assert targets[workspaces.provider_id].create+ else:+ with pytest.raises(NoPermissionError, match="workflow tools"):+ gateway.plan_workflow_tools(workspaces.target, [tool], creates_root_app=True)+ request_json = rbac_domain.transport.only_request.json+ assert request_json is not None+ assert request_json["scene"] == RBACPermission.TOOL_MANAGEdiff --git a/api/tests/unit_tests/services/test_app_dsl_service.py b/api/tests/unit_tests/services/test_app_dsl_service.pyindex ddb9459b5ea..03fb5cecd57 100644--- a/api/tests/unit_tests/services/test_app_dsl_service.py+++ b/api/tests/unit_tests/services/test_app_dsl_service.py@@ -38,6 +38,8 @@ _OVERWRITE_APP_ID = "11111111-1111-4111-8111-111111111111"_TENANT_ID = "22222222-2222-4222-8222-222222222222"_CALLER_ID = "33333333-3333-4333-8333-333333333333"_OTHER_ACCOUNT_ID = "44444444-4444-4444-8444-444444444444"+_WORKFLOW_TOOL_PROVIDER_ID = "77777777-7777-4777-8777-000000000000"+_API_TOOL_PROVIDER_ID = "88888888-8888-4888-8888-000000000000"_PENDING_WORKFLOW_DSL = "version: 99.0.0\nkind: app\napp: {name: Test, mode: workflow}\n"_PENDING_DATA_JSON = PendingData(tenant_id=_TENANT_ID,@@ -126,6 +128,7 @@ def test_import_rejects_cloud_app_quota_before_side_effects(dsl="",agents={},agent_resources={},+ workflow_tools=[],icons=[PackageIcon(id="i_000001", path="i_000001.png", size=0, sha256="0" * 64)],)monkeypatch.setattr(package, "materialize_icons", unexpected_side_effect)@@ -250,14 +253,25 @@ def test_confirm_import_rechecks_cloud_app_quota_and_preserves_pending_on_rejectassert f"app_import_info:{pending.id}" not in pending_imports-def test_extract_workflow_dependencies_includes_plugin_nodes(monkeypatch: pytest.MonkeyPatch) -> None:- monkeypatch.setattr(- "services.app_dsl_service.ToolNodeData.model_validate",- Mock(return_value=SimpleNamespace(provider_id="acme/tool/provider")),- )+def _tool_node_data(*, provider_type: str, provider_id: str, **extra: str) -> dict[str, object]:+ return {+ "type": "tool",+ "title": "Tool",+ "provider_id": provider_id,+ "provider_type": provider_type,+ "provider_name": provider_id,+ "tool_name": "run",+ "tool_label": "Run",+ "tool_configurations": {},+ "tool_parameters": {},+ **extra,+ }+++def test_extract_workflow_dependencies_includes_plugin_nodes() -> None:graph = {"nodes": [- {"data": {"type": "tool", "plugin_id": "acme/tool"}},+ {"data": _tool_node_data(provider_type="plugin", provider_id="acme/tool/provider", plugin_id="acme/tool")},{"data": {"type": "trigger-plugin", "plugin_id": "acme/trigger"}},{"data": {"type": "datasource", "provider_type": "online_document", "plugin_id": "acme/drive"}},{"data": {"type": "datasource", "provider_type": "local_file", "plugin_id": "langgenius/file"}},@@ -344,6 +358,32 @@ def test_extract_workflow_dependencies_tolerates_unresolved_llm_environment_refeanalyze_dependency.assert_called_once_with("old-provider")+def test_extract_workflow_dependencies_skips_workspace_tool_providers() -> None:+ graph = {+ "nodes": [+ {"data": _tool_node_data(provider_type="builtin", provider_id="time")},+ {"data": _tool_node_data(provider_type="workflow", provider_id=_WORKFLOW_TOOL_PROVIDER_ID)},+ {"data": _tool_node_data(provider_type="api", provider_id=_API_TOOL_PROVIDER_ID)},+ ]+ }++ assert AppDslService._extract_dependencies_from_workflow_graph(graph) == ["langgenius/time"]+++def test_extract_model_config_dependencies_skips_workspace_tool_providers() -> None:+ model_config = {+ "agent_mode": {+ "tools": [+ {"dataset": {"enabled": True, "id": "dataset-1"}},+ {"provider_type": "workflow", "provider_id": _WORKFLOW_TOOL_PROVIDER_ID, "tool_name": "summarize"},+ {"provider_type": "builtin", "provider_id": "time", "tool_name": "current_time"},+ ]+ }+ }++ assert AppDslService._extract_dependencies_from_model_config(model_config) == ["langgenius/time"]++def test_import_app_rejects_oversized_yaml_content_before_parsing(monkeypatch: pytest.MonkeyPatch, unbound_session: Session) -> None:diff --git a/api/tests/unit_tests/services/test_app_package_service.py b/api/tests/unit_tests/services/test_app_package_service.pyindex 25f53b41986..d8d68ff900f 100644--- a/api/tests/unit_tests/services/test_app_package_service.py+++ b/api/tests/unit_tests/services/test_app_package_service.py@@ -16,6 +16,7 @@ from sqlalchemy import Engine, selectfrom sqlalchemy.orm import Sessionfrom sqlalchemy.pool import QueuePool+from constants.dsl_version import CURRENT_APP_DSL_VERSIONfrom models import Account, App, AppModefrom models.agent import (Agent,@@ -51,6 +52,11 @@ from tests.helpers.unit.model_factories import make_account, make_app, make_tena"""Workflow packages restore node-owned Agents and assets across workspaces."""+def _bundle_any_app(app: App) -> bool:+ del app+ return True++class _MemoryStorage:def __init__(self) -> None:self.files: dict[str, bytes] = {}@@ -318,7 +324,9 @@ def _node_data(data: dict[str, object], node_id: str = "node-3") -> dict[str, obdef _roster_export(session: Session, storage: _MemoryStorage) -> bytes:app = _source(session, storage)_add_roster_node(session, app)- with AppPackageService().export_app(app_model=app, preserve_agent_bindings=True) as exported:+ with AppPackageService().export_app(+ may_bundle=_bundle_any_app, app_model=app, preserve_agent_bindings=True+ ) as exported:return exported.archive.read()@@ -354,7 +362,9 @@ class TestWorkflowPackageServiceCases: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:+ with AppPackageService().export_app(+ may_bundle=_bundle_any_app, app_model=app, workflow_id="workflow-1" if published else None+ ) as exported:content = exported.archive.read()with zipfile.ZipFile(io.BytesIO(content)) as archive:manifest = yaml.safe_load(archive.read("manifest.yaml"))@@ -440,7 +450,7 @@ class TestWorkflowPackageServiceCases:row.tenant_id = "tenant-elsewhere"sqlite_session.commit()with pytest.raises(RosterAgentPackageExportFailedError, match="payload is unavailable"):- AppPackageService().export_app(app_model=app)+ AppPackageService().export_app(may_bundle=_bundle_any_app, app_model=app)@staticmethod@pytest.mark.parametrize(@@ -452,7 +462,7 @@ class TestWorkflowPackageServiceCases:mutation: str,) -> None:app = _source(sqlite_session, storage)- with AppPackageService().export_app(app_model=app) as exported:+ with AppPackageService().export_app(may_bundle=_bundle_any_app, app_model=app) as exported:content = exported.archive.read()def mutate(manifest: AppPackageManifest, data: dict[str, object], members: dict[str, bytes]) -> None:@@ -484,7 +494,7 @@ class TestWorkflowPackageServiceCases:monkeypatch: pytest.MonkeyPatch,) -> None:app = _source(sqlite_session, storage)- with AppPackageService().export_app(app_model=app) as exported:+ with AppPackageService().export_app(may_bundle=_bundle_any_app, app_model=app) as exported:content = exported.archive.read()def mutate(manifest: AppPackageManifest, data: dict[str, object], members: dict[str, bytes]) -> None:@@ -518,7 +528,7 @@ class TestWorkflowPackageServiceCases:monkeypatch: pytest.MonkeyPatch,) -> None:app = _source(sqlite_session, storage)- with AppPackageService().export_app(app_model=app) as exported:+ with AppPackageService().export_app(may_bundle=_bundle_any_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):@@ -532,7 +542,7 @@ class TestWorkflowPackageServiceCases:monkeypatch: pytest.MonkeyPatch,) -> None:app = _source(sqlite_session, storage)- with AppPackageService().export_app(app_model=app) as exported:+ with AppPackageService().export_app(may_bundle=_bundle_any_app, app_model=app) as exported:content = exported.archive.read()original = _import(sqlite_session, content)assert original.status == ImportStatus.COMPLETED, original.error@@ -602,7 +612,7 @@ class TestWorkflowPackageServiceCases:monkeypatch.setattr(storage, "load_stream", checked_load)monkeypatch.setattr(storage, "save", checked_save)- with AppPackageService().export_app(app_model=app) as exported:+ with AppPackageService().export_app(may_bundle=_bundle_any_app, app_model=app) as exported:content = exported.archive.read()result = _import(sqlite_session, content)assert result.status == ImportStatus.COMPLETED, result.error@@ -617,7 +627,7 @@ class TestWorkflowPackageServiceCases:soul.config_files[0].file_id = ""snapshot.config_snapshot = soulsqlite_session.commit()- with AppPackageService().export_app(app_model=app) as exported:+ with AppPackageService().export_app(may_bundle=_bundle_any_app, app_model=app) as exported:result = _import(sqlite_session, exported.archive.read())assert result.status == ImportStatus.COMPLETED_WITH_WARNINGS, result.errorassert any(warning.code == "agent_file_omitted" for warning in result.warnings)@@ -625,7 +635,7 @@ class TestWorkflowPackageServiceCases:@staticmethoddef test_reader_keeps_legacy_packaged_roster_nodes(sqlite_session: Session, storage: _MemoryStorage) -> None:app = _source(sqlite_session, storage)- with AppPackageService().export_app(app_model=app) as exported:+ with AppPackageService().export_app(may_bundle=_bundle_any_app, app_model=app) as exported:content = exported.archive.read()def mutate(_manifest: AppPackageManifest, data: dict[str, object], _members: dict[str, bytes]) -> None:@@ -640,7 +650,9 @@ class TestWorkflowPackageServiceCases:def test_package_export_keeps_roster_references(sqlite_session: Session, storage: _MemoryStorage) -> None:app = _source(sqlite_session, storage)_add_roster_node(sqlite_session, app)- with AppPackageService().export_app(app_model=app, preserve_agent_bindings=True) as exported:+ with AppPackageService().export_app(+ may_bundle=_bundle_any_app, app_model=app, preserve_agent_bindings=True+ ) as exported:data, manifest = _read_export(exported.archive.read())node = _node_data(data)assert node["agent_binding"] == {@@ -669,7 +681,9 @@ class TestWorkflowPackageServiceCases:sqlite_session.add_all([app, workflow])sqlite_session.commit()_add_roster_node(sqlite_session, app)- with AppPackageService().export_app(app_model=app, preserve_agent_bindings=True) as exported:+ with AppPackageService().export_app(+ may_bundle=_bundle_any_app, app_model=app, preserve_agent_bindings=True+ ) as exported:data, manifest = _read_export(exported.archive.read())assert not manifest.get("agent_resources")assert cast(dict[str, object], _node_data(data)["agent_binding"])["agent_id"] == "roster-agent-1"@@ -681,7 +695,7 @@ class TestWorkflowPackageServiceCases:app = _source(sqlite_session, storage, published=True)_add_roster_node(sqlite_session, app, graph_binding={"binding_type": "roster_agent", "agent_id": "stale-agent"})with AppPackageService().export_app(- app_model=app, workflow_id="workflow-1", preserve_agent_bindings=True+ may_bundle=_bundle_any_app, app_model=app, workflow_id="workflow-1", preserve_agent_bindings=True) as exported:content = exported.archive.read()data, _manifest = _read_export(content)@@ -798,7 +812,7 @@ def _roster_archive(binding: dict[str, object], agent_job: dict[str, object] | N"workflow": {"graph": {"nodes": [{"id": "node-1", "data": node_data}], "edges": []}},})- with AppPackageService().export(dsl=dsl, name="Roster") as package:+ with AppPackageService().export(dsl=dsl, name="Roster", workflow_tools=[]) as package:return io.BytesIO(package.archive.read())@@ -809,7 +823,7 @@ class TestAppPackageServiceCases:def test_round_trip_retains_exact_dsl_and_defers_version_handling(mode: str, version: str) -> None:dsl = f"kind: app\nversion: {version}\napp:\n mode: {mode}\n# Preserve the DSL verbatim.\n"service = AppPackageService()- with service.export(dsl=dsl, name="Example App") as package:+ with service.export(dsl=dsl, name="Example App", workflow_tools=[]) as package:assert package.filename == "example-app.ifpkg"prepared = service.read_package(package.archive)assert prepared is not None@@ -868,7 +882,7 @@ class TestAppPackageServiceCases:def test_package_round_trip_accepts_large_dsl_within_legacy_limit(size: int) -> None:dsl = _dsl_with_size(size)service = AppPackageService()- with service.export(dsl=dsl, name="Large Workflow") as package:+ with service.export(dsl=dsl, name="Large Workflow", workflow_tools=[]) as package:prepared = service.read_package(package.archive)assert prepared is not Nonewith prepared:@@ -878,7 +892,7 @@ class TestAppPackageServiceCases:def test_export_rejects_dsl_exceeding_legacy_byte_limit() -> None:dsl = _dsl_with_size(DSL_MAX_SIZE + 1)with pytest.raises(RosterAgentPackageTooLargeError):- AppPackageService().export(dsl=dsl, name="Large Workflow")+ AppPackageService().export(dsl=dsl, name="Large Workflow", workflow_tools=[])@staticmethoddef test_import_rejects_compressed_dsl_exceeding_legacy_byte_limit() -> None:@@ -914,19 +928,188 @@ class TestAppPackageServiceCases:@staticmethoddef test_non_workflow_package_is_accepted_when_roster_references_accepted() -> None:dsl = yaml.safe_dump({"kind": "app", "app": {"mode": "chat", "name": "Chat"}})- with AppPackageService().export(dsl=dsl, name="Chat") as package:+ with AppPackageService().export(dsl=dsl, name="Chat", workflow_tools=[]) as package:prepared = AppPackageService().read_package(package.archive, accept_roster_references=True)assert prepared is not Noneassert prepared.agents == {}prepared.close()+"""Packages bundle the workflows an App calls through Workflow Tools as nested App packages."""++_WORKFLOW_DSL = f"kind: app\nversion: {CURRENT_APP_DSL_VERSION}\napp:\n mode: workflow\n"+++def _nested_package(dsl: str) -> bytes:+ with AppPackageService().export(dsl=dsl, name="Summarize", workflow_tools=[]) as exported:+ return exported.archive.read()+++def _workflow_tool(index: int, member: bytes, **overrides: object) -> dict[str, object]:+ return {+ "id": f"w_{index:06d}",+ "path": f"w_{index:06d}.ifpkg",+ "size": len(member),+ "sha256": hashlib.sha256(member).hexdigest(),+ "provider_id": f"33333333-3333-4333-8333-{index:012d}",+ "name": f"summarize_{index}",+ "label": "Summarize",+ "icon": {"background": "#FFEAD5", "content": "🤖"},+ "description": "Summarize a document",+ "parameters": [{"name": "document", "description": "Document", "form": "llm"}],+ "labels": ["productivity"],+ "privacy_policy": "",+ **overrides,+ }+++def _bundle(+ members: list[bytes], *, root_dsl: str = _WORKFLOW_DSL, format_version: int = 2, **tool_overrides: object+) -> io.BytesIO:+ tools = [_workflow_tool(index, member, **tool_overrides) for index, member in enumerate(members, start=1)]+ source = _archive(root_dsl, format_version=format_version, workflow_tools=tools)+ with zipfile.ZipFile(source, "a") as archive:+ for tool, member in zip(tools, members, strict=True):+ archive.writestr(str(tool["path"]), member)+ source.seek(0)+ return source+++class TestWorkflowToolPackageCases:+ @staticmethod+ def test_reads_bundled_workflow_tools_and_opens_each_as_an_app_package() -> None:+ member = _nested_package(_WORKFLOW_DSL)++ prepared = AppPackageService().read_package(_bundle([member]))++ assert prepared is not None+ with prepared:+ assert prepared.dsl == _WORKFLOW_DSL+ [tool] = prepared.workflow_tools+ assert (tool.provider_id, tool.name, tool.labels) == (+ "33333333-3333-4333-8333-000000000001",+ "summarize_1",+ ["productivity"],+ )+ with prepared.open_workflow_tool(tool) as nested:+ assert nested.dsl == _WORKFLOW_DSL+ assert nested.workflow_tools == []++ @staticmethod+ @pytest.mark.parametrize(+ ("format_version", "tool_overrides"),+ [+ (1, {}),+ (2, {"name": "not a tool name"}),+ (2, {"provider_id": "not-a-uuid"}),+ (2, {"path": "w_000009.ifpkg"}),+ ],+ ids=["v1-with-tools", "invalid-name", "invalid-provider-id", "path-without-its-id"],+ )+ def test_rejects_invalid_workflow_tool_manifests(format_version: int, tool_overrides: dict[str, str]) -> None:+ member = _nested_package(_WORKFLOW_DSL)+ with pytest.raises(InvalidRosterAgentPackageError, match="manifest"):+ AppPackageService().read_package(_bundle([member], format_version=format_version, **tool_overrides))++ @staticmethod+ def test_rejects_workflow_tool_checksum_mismatch() -> None:+ member = _nested_package(_WORKFLOW_DSL)+ with pytest.raises(InvalidRosterAgentPackageError, match="integrity"):+ AppPackageService().read_package(_bundle([member], sha256="0" * 64))++ @staticmethod+ @pytest.mark.parametrize(+ "nested_dsl",+ [+ f"kind: app\nversion: {CURRENT_APP_DSL_VERSION}\napp:\n mode: advanced-chat\n",+ "kind: app\nversion: 99.0.0\napp:\n mode: workflow\n",+ ],+ ids=["not-a-workflow", "needs-version-confirmation"],+ )+ def test_rejects_workflow_tools_that_cannot_import_with_the_package(nested_dsl: str) -> None:+ with pytest.raises(InvalidRosterAgentPackageError):+ AppPackageService().read_package(_bundle([_nested_package(nested_dsl)]))++ @staticmethod+ def test_rejects_a_root_app_that_needs_version_confirmation_with_workflow_tools() -> None:+ member = _nested_package(_WORKFLOW_DSL)+ root_dsl = "kind: app\nversion: 99.0.0\napp:\n mode: workflow\n"+ with pytest.raises(InvalidRosterAgentPackageError, match="confirmation"):+ AppPackageService().read_package(_bundle([member], root_dsl=root_dsl))++ @staticmethod+ def test_rejects_workflow_tools_that_bundle_workflow_tools() -> None:+ nested = _bundle([_nested_package(_WORKFLOW_DSL)]).getvalue()+ with pytest.raises(InvalidRosterAgentPackageError, match="must not bundle"):+ AppPackageService().read_package(_bundle([nested]))++ @staticmethod+ def test_rejects_more_workflow_tools_than_the_limit(config_overrides: Callable[..., None]) -> None:+ member = _nested_package(_WORKFLOW_DSL)+ config_overrides(APP_PACKAGE_MAX_WORKFLOW_TOOLS=1)+ with pytest.raises(RosterAgentPackageTooLargeError, match="too many workflow tools"):+ AppPackageService().read_package(_bundle([member, member]))++ @staticmethod+ def test_rejects_workflow_tools_that_share_a_provider_id() -> None:+ member = _nested_package(_WORKFLOW_DSL)+ with pytest.raises(InvalidRosterAgentPackageError, match="manifest"):+ AppPackageService().read_package(+ _bundle([member, member], provider_id="33333333-3333-4333-8333-000000000009")+ )++ @staticmethod+ def test_rejects_a_workflow_tool_larger_than_declared() -> None:+ member = _nested_package(_WORKFLOW_DSL)+ with pytest.raises(InvalidRosterAgentPackageError, match="integrity"):+ AppPackageService().read_package(_bundle([member], size=1))++ @staticmethod+ def test_rejects_a_workflow_tool_that_is_an_agent_package() -> None:+ member = io.BytesIO()+ with zipfile.ZipFile(member, "w") as archive:+ archive.writestr("manifest.yaml", yaml.safe_dump({"format": "dify.roster-agent", "format_version": 1}))+ with pytest.raises(InvalidRosterAgentPackageError, match="must be an App package"):+ AppPackageService().read_package(_bundle([member.getvalue()]))++ @staticmethod+ def test_rejects_a_corrupted_workflow_tool_member() -> None:+ source = _bundle([_nested_package(_WORKFLOW_DSL)])+ with zipfile.ZipFile(source) as archive:+ offset = archive.getinfo("w_000001.ifpkg").header_offset+ payload = bytearray(source.getvalue())+ # A local file header is 30 bytes, then the member name and extra field, then the stored data.+ name_length = int.from_bytes(payload[offset + 26 : offset + 28], "little")+ extra_length = int.from_bytes(payload[offset + 28 : offset + 30], "little")+ payload[offset + 30 + name_length + extra_length] ^= 0xFF+ with pytest.raises(InvalidRosterAgentPackageError, match="not a valid ZIP"):+ AppPackageService().read_package(io.BytesIO(bytes(payload)))++ @staticmethod+ def test_bounds_what_all_workflow_tools_expand_to(config_overrides: Callable[..., None]) -> None:+ dsl = f"{_WORKFLOW_DSL} description: {'a' * 60_000}\n"+ member = _nested_package(dsl)+ config_overrides(AGENT_PACKAGE_MAX_BYTES=100_000)+ with pytest.raises(RosterAgentPackageTooLargeError, match="workflow tools exceed"):+ AppPackageService().read_package(_bundle([member, member]))++ @staticmethod+ def test_the_app_and_its_workflow_tools_share_one_size_limit(config_overrides: Callable[..., None]) -> None:+ member = _nested_package(f"{_WORKFLOW_DSL} description: {'a' * 60_000}\n")+ root_dsl = f"{_WORKFLOW_DSL} description: {'b' * 50_000}\n"+ config_overrides(AGENT_PACKAGE_MAX_BYTES=100_000)+ with pytest.raises(RosterAgentPackageTooLargeError, match="App package and its workflow tools exceed"):+ AppPackageService().read_package(_bundle([member], root_dsl=root_dsl))++"""Packaged image icons travel with Apps and receive destination-owned file ids."""def _icon_archive(*, payload: bytes = b"image", digest: str | None = None, reference: str = "i_000001") -> io.BytesIO:dsl = yaml.safe_dump({"kind": "app", "app": {"mode": "chat", "icon_type": "image", "icon": reference}})- with AppPackageService().export(dsl=dsl.replace(reference, "legacy-id"), name="Example") as exported:+ with AppPackageService().export(+ dsl=dsl.replace(reference, "legacy-id"), name="Example", workflow_tools=[]+ ) as exported:with zipfile.ZipFile(exported.archive) as package:manifest = yaml.safe_load(package.read("manifest.yaml"))app_bytes = dsl.encode()@@ -966,7 +1149,7 @@ class TestPackageIconsCases:assert upload_lookup.call_args.kwargs["tenant_id"] == "source-tenant"assert upload_lookup.call_count == 1dsl = yaml.safe_dump({"kind": "app", "app": metadata})- with AppPackageService().export(dsl=dsl, name="Example", resources=exporter) as exported:+ with AppPackageService().export(dsl=dsl, name="Example", resources=exporter, workflow_tools=[]) as exported:with zipfile.ZipFile(exported.archive) as package:assert package.read("i_000001.png") == payloadexported.archive.seek(0)@@ -1000,7 +1183,10 @@ class TestPackageIconsCases:exporter.collect_icon(session=Mock(), tenant_id="source", metadata=app)exporter.collect_icon(session=Mock(), tenant_id="source", metadata=site)with AppPackageService().export(- dsl=yaml.safe_dump({"kind": "app", "app": app, "site": site}), name="App", resources=exporter+ dsl=yaml.safe_dump({"kind": "app", "app": app, "site": site}),+ name="App",+ resources=exporter,+ workflow_tools=[],) as exported:prepared = AppPackageService().read_package(exported.archive)assert prepared is not Nonediff --git a/api/tests/unit_tests/services/test_workflow_tool_references.py b/api/tests/unit_tests/services/test_workflow_tool_references.pynew file mode 100644index 00000000000..ed83ce1b84e--- /dev/null+++ b/api/tests/unit_tests/services/test_workflow_tool_references.py@@ -0,0 +1,92 @@+"""Workflow Tool references are found in every DSL shape that can call one, and retargeted in place."""++import yaml++from services.workflow_tool_references import (+ WorkflowToolTarget,+ iter_workflow_tool_references,+ retarget_workflow_tool_dsl,+)++_SOURCE_ID = "11111111-1111-4111-8111-111111111111"+_TARGET_ID = "22222222-2222-4222-8222-222222222222"+_TOOL_NODE = {+ "type": "tool",+ "provider_type": "workflow",+ "provider_id": _SOURCE_ID,+ "provider_name": "Summarize",+ "tool_name": "summarize",+}+_BUILTIN_NODE = {"type": "tool", "provider_type": "builtin", "provider_id": "time", "tool_name": "now"}+_AGENT_WORKFLOW_TOOL = {"type": "workflow", "provider_name": _SOURCE_ID, "tool_name": "summarize"}+_AGENT_BUILTIN_TOOL = {"type": "builtin", "provider_name": "time", "tool_name": "now"}+++def _workflow_dsl() -> dict[str, object]:+ agent_tools = {"type": "constant", "value": [dict(_AGENT_WORKFLOW_TOOL), dict(_AGENT_BUILTIN_TOOL)]}+ return {+ "kind": "app",+ "app": {"mode": "workflow"},+ "workflow": {+ "graph": {+ "nodes": [+ {"id": "tool", "data": dict(_TOOL_NODE)},+ {"id": "builtin", "data": dict(_BUILTIN_NODE)},+ {"id": "agent", "data": {"type": "agent", "agent_parameters": {"tools": agent_tools}}},+ {"id": "without-data"},+ ]+ }+ },+ }+++def test_references_cover_tool_nodes_and_legacy_agent_tools() -> None:+ references = list(iter_workflow_tool_references(_workflow_dsl()))++ assert [(reference.id_key, reference.provider_id) for reference in references] == [+ ("provider_id", _SOURCE_ID),+ ("provider_name", _SOURCE_ID),+ ]+++def test_references_cover_agent_chat_tools() -> None:+ data = {+ "model_config": {+ "agent_mode": {+ "tools": [+ {"provider_type": "workflow", "provider_id": _SOURCE_ID, "tool_name": "summarize"},+ {"dataset": {"enabled": True, "id": "dataset-1"}},+ "not-a-tool",+ ]+ }+ }+ }++ assert [reference.provider_id for reference in iter_workflow_tool_references(data)] == [_SOURCE_ID]+++def test_retarget_points_known_references_at_their_targets() -> None:+ dsl = yaml.safe_dump(_workflow_dsl())+ targets = {_SOURCE_ID: WorkflowToolTarget(provider_id=_TARGET_ID, name="summarize_2", create=True)}++ nodes = yaml.safe_load(retarget_workflow_tool_dsl(dsl, targets))["workflow"]["graph"]["nodes"]++ assert nodes[0]["data"] == {**_TOOL_NODE, "provider_id": _TARGET_ID, "tool_name": "summarize_2"}+ assert nodes[1]["data"] == _BUILTIN_NODE+ agent_tools = nodes[2]["data"]["agent_parameters"]["tools"]["value"]+ assert agent_tools == [+ {**_AGENT_WORKFLOW_TOOL, "provider_name": _TARGET_ID, "tool_name": "summarize_2"},+ _AGENT_BUILTIN_TOOL,+ ]+++def test_retarget_keeps_providers_without_a_target() -> None:+ dsl = yaml.safe_dump(_workflow_dsl())++ assert yaml.safe_load(retarget_workflow_tool_dsl(dsl, {})) == _workflow_dsl()+++def test_retarget_leaves_a_dsl_that_is_not_a_mapping_unchanged() -> None:+ targets = {_SOURCE_ID: WorkflowToolTarget(provider_id=_TARGET_ID, name="summarize", create=True)}++ assert retarget_workflow_tool_dsl("[]\n", targets) == "[]\n"diff --git a/docker/envs/core-services/shared.env.example b/docker/envs/core-services/shared.env.exampleindex 0f736eb56b7..fc004d00454 100644--- a/docker/envs/core-services/shared.env.example+++ b/docker/envs/core-services/shared.env.example@@ -77,6 +77,7 @@ SKILL_PACKAGE_MAX_SKILL_MD_BYTES=1048576AGENT_PACKAGE_MAX_BYTES=536870912AGENT_PACKAGE_MAX_MANIFEST_BYTES=5242880AGENT_PACKAGE_MAX_ENTRIES=5000+APP_PACKAGE_MAX_WORKFLOW_TOOLS=20API_SENTRY_DSN=API_SENTRY_TRACES_SAMPLE_RATE=1.0API_SENTRY_PROFILES_SAMPLE_RATE=1.0