Skip to content

armgit / dify

Public Imported from GitHub
0

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

feat(api): bundle called workflow tools in app packages (#44592)

-LAN-2fc0a6712505
diff --git a/api/.env.example b/api/.env.example
index 94f189af26b..16226a49fd8 100644
--- a/api/.env.example
+++ b/api/.env.example
@@ -483,6 +483,7 @@ SKILL_PACKAGE_MAX_SKILL_MD_BYTES=1048576
AGENT_PACKAGE_MAX_BYTES=536870912
AGENT_PACKAGE_MAX_MANIFEST_BYTES=5242880
AGENT_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__.py
index 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.py
index 8ba6723ea22..869e75c5a87 100644
--- a/api/services/app/console_gateway.py
+++ b/api/services/app/console_gateway.py
@@ -3,26 +3,29 @@
from __future__ import annotations
import copy
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
from contextlib import AbstractContextManager
from dataclasses import dataclass, replace
from typing import Any, BinaryIO, Final, Literal, override
-from uuid import UUID
+from uuid import UUID, uuid4
+from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
-from core.rbac import RBACPermission
+from core.rbac import RBACPermission, RBACResourceScope
from enums import DeploymentEdition
from events.app_event import app_was_updated
from graphon.enums import BuiltinNodeTypes
from graphon.model_runtime.entities.llm_entities import LLMMode
from graphon.model_runtime.entities.message_entities import PromptMessageRole
+from libs.datetime_utils import naive_utc_now
from machinery.context import RequestContext
from models.account import Account
from models.agent import AgentIconType
-from models.model import AppMode
+from models.model import App, AppMode
+from models.tools import WorkflowToolProvider
from repositories.app.console_repository import ConsoleAppRepository, console_app_actor, require_console_app
from repositories.app.response import app_record
from services.agent.errors import AgentNameConflictError
@@ -65,6 +68,7 @@ from services.entities.dsl_entities import (
DraftGuardedImportParams,
Import,
ImportStatus,
+ PackagedWorkflowTool,
)
from services.errors.base import NoPermissionError
from services.feature_service import FeatureService
@@ -72,7 +76,9 @@ from services.rbac import contracts as rbac_contracts
from services.rbac.members import MemberService
from services.recommended_app_package_service import RecommendedAppPackageService
from services.system_feature_service import SystemFeatureService
+from services.tools.workflow_tools_manage_service import WorkflowToolManageService
from services.workflow_service import WorkflowService
+from services.workflow_tool_references import WorkflowToolTarget
from 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,
+ )
+
@override
def 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,
)
@override
diff --git a/api/services/app/console_service.py b/api/services/app/console_service.py
index 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 Sequence
from contextlib import AbstractContextManager, closing
from dataclasses import replace
from 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.py
index 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_encoder
from graphon.nodes.llm.entities import LLMNodeData, ModelConfig
from graphon.nodes.parameter_extractor.entities import ParameterExtractorNodeData
from graphon.nodes.question_classifier.entities import QuestionClassifierNodeData
-from graphon.nodes.tool.entities import ToolNodeData
+from graphon.nodes.tool.entities import ToolNodeData, ToolProviderType
from libs.datetime_utils import naive_utc_now
from models import Account, App, AppMode
from 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 minutes
CURRENT_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_id
if 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:
+ return
try:
apps = FeatureService.get_features(tenant_id, exclude_vector_space=True).apps
except 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:
+ continue
dependencies.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:
+ continue
dependencies.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.py
index 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 re
import tempfile
import zipfile
import zlib
-from collections.abc import Iterator, Mapping
+from collections.abc import Callable, Iterator, Mapping, Sequence
from dataclasses import dataclass, field
from typing import Any, BinaryIO, Literal, Self, cast
import yaml
from 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_VERSION
from core.db.session_factory import session_factory
+from core.tools.entities.tool_entities import ToolProviderType, emoji_icon_adapter
from core.workflow.nodes.agent_v2.validators import WorkflowAgentNodeValidator
from models.agent import WorkflowAgentBindingType
from models.agent_config_entities import WorkflowNodeJobConfig
from models.model import App, AppMode
+from models.tools import ToolLabelBinding, WorkflowToolProvider
+from models.workflow import Workflow
from services.agent.dsl_entities import AGENT_NODE_JOB_DSL_KEY, AGENT_PACKAGE_REF_KEY, AgentPackage
from services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError
from services.agent.package_resource_exporter import AgentPackageResourceExporter
@@ -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 AppDslService
from 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, PackagedWorkflowTool
from 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: str
agents: 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: SIM115
try:
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):
raise
finally:
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"
+ )
@classmethod
def _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.py
index fb97e7ee89a..9f21501b0fd 100644
--- a/api/services/entities/dsl_entities.py
+++ b/api/services/entities/dsl_entities.py
@@ -1,12 +1,14 @@
from dataclasses import dataclass
from enum import StrEnum
-from typing import Any, Protocol
+from typing import Any, Protocol, Self
from uuid import UUID
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
from constants.dsl_version import CURRENT_APP_DSL_VERSION
from core.plugin.entities.plugin import PluginDependency
+from core.tools.entities.tool_entities import EmojiIconDict, WorkflowToolParameterConfiguration
+from libs.helper import alphanumeric, uuid_value
from 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]
@property
def 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.py
new file mode 100644
index 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.py
index 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.py
index 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 = status
dsl = "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.py
index 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 == status
assert len(archives) == 1
diff --git a/api/tests/unit_tests/services/app/test_console_service.py b/api/tests/unit_tests/services/app/test_console_service.py
index 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 base64
import json
-from collections.abc import Sequence
+import os
+from collections.abc import Callable, Sequence
from contextlib import AbstractContextManager
from dataclasses import dataclass, field, replace
from datetime import datetime
from io import BytesIO
from typing import BinaryIO, Literal, cast, override
from uuid import UUID, uuid4
+from zipfile import ZipFile
import pytest
+import yaml
+from blinker import Signal
from sqlalchemy import Engine, event, func, select
from sqlalchemy.orm import Session, sessionmaker
+from core.plugin.entities.plugin import PluginDependency
from 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, ToolProviderType
from core.tools.tool_manager import ToolManager
from 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_client
from graphon.model_runtime.entities.model_entities import ModelType
+from libs.datetime_utils import naive_utc_now
from machinery.context import RequestContext
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
from models.agent import Agent, AgentConfigSnapshot, AgentStatus
@@ -25,12 +36,20 @@ from models.agent_config_entities import AgentSoulConfig
from models.model import App, AppMode, AppModelConfig, IconType, InstalledApp, Site
from models.provider import TenantDefaultModel
from models.provider_ids import GenericProviderID
-from models.tools import ApiToolProvider
+from models.tools import ApiToolProvider, ToolLabelBinding, WorkflowToolProvider
+from models.workflow import Workflow, WorkflowType
from 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 RosterAgentPackageImporter
from services.agent.roster_service import AgentRosterService
-from services.app.console_gateway import AppLifecycleGateway
+from services.app.console_gateway import AppLifecycleGateway, AppTransferGateway
from 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 AppPackageService
from services.app_tracing_config_service import AppTraceSettings
from 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 FeatureService
from 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 RBACDomain
CONTEXT = 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_id
pytest.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_e
assert not persisted.enable_api
finally:
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_MANAGE
diff --git a/api/tests/unit_tests/services/test_app_dsl_service.py b/api/tests/unit_tests/services/test_app_dsl_service.py
index 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_reject
assert 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_refe
analyze_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.py
index 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, select
from sqlalchemy.orm import Session
from sqlalchemy.pool import QueuePool
+from constants.dsl_version import CURRENT_APP_DSL_VERSION
from models import Account, App, AppMode
from 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, ob
def _roster_export(session: Session, storage: _MemoryStorage) -> bytes:
app = _source(session, storage)
_add_roster_node(session, app)
- with AppPackageService().export_app(app_model=app, preserve_agent_bindings=True) as exported:
+ 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 = soul
sqlite_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.error
assert any(warning.code == "agent_file_omitted" for warning in result.warnings)
@@ -625,7 +635,7 @@ class TestWorkflowPackageServiceCases:
@staticmethod
def test_reader_keeps_legacy_packaged_roster_nodes(sqlite_session: Session, storage: _MemoryStorage) -> None:
app = _source(sqlite_session, storage)
- with AppPackageService().export_app(app_model=app) as exported:
+ 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 None
with 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=[])
@staticmethod
def test_import_rejects_compressed_dsl_exceeding_legacy_byte_limit() -> None:
@@ -914,19 +928,188 @@ class TestAppPackageServiceCases:
@staticmethod
def test_non_workflow_package_is_accepted_when_roster_references_accepted() -> None:
dsl = yaml.safe_dump({"kind": "app", "app": {"mode": "chat", "name": "Chat"}})
- with AppPackageService().export(dsl=dsl, name="Chat") as package:
+ 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 None
assert 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 == 1
dsl = 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") == payload
exported.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 None
diff --git a/api/tests/unit_tests/services/test_workflow_tool_references.py b/api/tests/unit_tests/services/test_workflow_tool_references.py
new file mode 100644
index 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.example
index 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=1048576
AGENT_PACKAGE_MAX_BYTES=536870912
AGENT_PACKAGE_MAX_MANIFEST_BYTES=5242880
AGENT_PACKAGE_MAX_ENTRIES=5000
+APP_PACKAGE_MAX_WORKFLOW_TOOLS=20
API_SENTRY_DSN=
API_SENTRY_TRACES_SAMPLE_RATE=1.0
API_SENTRY_PROFILES_SAMPLE_RATE=1.0