Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): centralize API key management (#42489)
Byron.wang8b7f903cffd8
diff --git a/api/controllers/console/agent/roster.py b/api/controllers/console/agent/roster.pyindex aebe3a746e3..27e81239f48 100644--- a/api/controllers/console/agent/roster.py+++ b/api/controllers/console/agent/roster.py@@ -18,7 +18,7 @@ from controllers.common.schema import ()from controllers.common.session import with_sessionfrom controllers.console import console_ns-from controllers.console.apikey import ApiKeyItem, ApiKeyList, BaseApiKeyListResource, BaseApiKeyResource+from controllers.console.apikey import API_KEY_DELETE_ROLES, API_KEY_EDIT_ROLES, api_key_errorsfrom controllers.console.app.app import (APP_LIST_QUERY_ARRAY_FIELDS,AppListQuery,@@ -35,6 +35,7 @@ from controllers.console.app.app import (from controllers.console.app.app import (UpdateAppPayload as GenericUpdateAppPayload,)+from controllers.console.flask_admission import console_account_admissionfrom controllers.console.wraps import (RBACPermission,account_initialization_required,@@ -49,6 +50,7 @@ from controllers.console.wraps import ()from core.agent.publish_visibility import agent_has_workflow_callable_active_snapshotfrom enums import DeploymentEdition+from extensions.ext_application_services import application_servicesfrom fields.agent_fields import (AgentConfigDraftSummaryResponse,AgentConfigSnapshotDetailResponse,@@ -63,10 +65,12 @@ from fields.agent_fields import (AgentRosterListResponse,AgentStatisticSummaryEnvelopeResponse,)+from fields.api_key_fields import ApiKeyItem, ApiKeyListfrom fields.base import ResponseModelfrom libs.datetime_utils import parse_time_rangefrom libs.helper import dump_responsefrom libs.login import login_required+from machinery.context import RequestContextfrom models import Accountfrom models.agent import Agent, AgentStatusfrom models.agent_config_entities import AgentSoulConfig@@ -1039,56 +1043,44 @@ class AgentApiStatusApi(Resource):@console_ns.route("/agent/<uuid:agent_id>/api-keys")-class AgentApiKeyListApi(BaseApiKeyListResource):- resource_type = ApiTokenType.APP- resource_model = App- resource_id_field = "app_id"- token_prefix = "app-"-+class AgentApiKeyListApi(Resource):@console_ns.response(200, "Agent service API keys", console_ns.models[ApiKeyList.__name__])- @rbac_permission_required(RBACCheck(RBACPermission.AGENT_ACCESS_POINT_VIEW, AgentId()))- @with_current_tenant_id- @edit_permission_required- @with_session(write=False)- def get(self, session: Session, tenant_id: str, agent_id: UUID) -> dict[str, object]:- app_model = _resolve_agent_app_model(session, tenant_id=tenant_id, agent_id=agent_id)- return dump_response(ApiKeyList, self._get_api_key_list(str(app_model.id), tenant_id, session=session))+ @console_account_admission(+ allowed_roles=API_KEY_EDIT_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.AGENT_ACCESS_POINT_VIEW, AgentId())],+ )+ def get(self, request_context: RequestContext, agent_id: UUID) -> dict[str, object]:+ with api_key_errors():+ keys = application_services().app_api_keys.list_agent_keys(request_context, str(agent_id))+ return dump_response(ApiKeyList, {"data": keys})@console_ns.response(201, "Agent service API key created", console_ns.models[ApiKeyItem.__name__])@console_ns.response(400, "Maximum keys exceeded")- @with_current_tenant_id- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentId()))- @with_session- def post(self, session: Session, tenant_id: str, agent_id: UUID) -> tuple[dict[str, object], int]:- app_model = _resolve_agent_app_model(session, tenant_id=tenant_id, agent_id=agent_id)- return dump_response(- ApiKeyItem,- self._create_api_key(str(app_model.id), tenant_id, session=session),- ), 201+ @console_account_admission(+ allowed_roles=API_KEY_EDIT_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentId())],+ )+ def post(self, request_context: RequestContext, agent_id: UUID) -> tuple[dict[str, object], int]:+ with api_key_errors():+ key = application_services().app_api_keys.create_agent_key(request_context, str(agent_id))+ return dump_response(ApiKeyItem, key), 201@console_ns.route("/agent/<uuid:agent_id>/api-keys/<uuid:api_key_id>")-class AgentApiKeyApi(BaseApiKeyResource):- resource_type = ApiTokenType.APP- resource_model = App- resource_id_field = "app_id"-+class AgentApiKeyApi(Resource):@console_ns.response(204, "Agent service API key deleted")- @with_current_user- @with_current_tenant_id- @rbac_permission_required(RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentId()))- @with_session+ @console_account_admission(+ allowed_roles=API_KEY_DELETE_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentId())],+ )def delete(self,- session: Session,- tenant_id: str,- current_user: Account,+ request_context: RequestContext,agent_id: UUID,api_key_id: UUID,) -> tuple[str, int]:- app_model = _resolve_agent_app_model(session, tenant_id=tenant_id, agent_id=agent_id)- self._delete_api_key(str(app_model.id), str(api_key_id), tenant_id, current_user, session=session)+ with api_key_errors():+ application_services().app_api_keys.delete_agent_key(request_context, str(agent_id), str(api_key_id))return "", 204diff --git a/api/controllers/console/apikey.py b/api/controllers/console/apikey.pyindex 7519d0caa8f..2b833bfb2a1 100644--- a/api/controllers/console/apikey.py+++ b/api/controllers/console/apikey.py@@ -1,390 +1,151 @@-from collections.abc import Iterable, Mapping-from datetime import datetime+"""Console transport adapters for resource-scoped API key management."""++from collections.abc import Generator+from contextlib import contextmanagerfrom uuid import UUIDimport flask_restxfrom flask_restx import Resource-from flask_restx._http import HTTPStatus-from pydantic import field_validator-from sqlalchemy import func, or_, select-from sqlalchemy.orm import Session-from werkzeug.exceptions import Forbidden-from configs import dify_configfrom controllers.common.rbac import AgentBehindApp, DatasetId, PlainApp, RBACCheckfrom controllers.common.schema import register_response_schema_models-from controllers.common.session import with_session-from fields.base import ResponseModel-from libs.helper import dump_response, to_timestamp-from libs.login import login_required-from models import Account-from models.dataset import Dataset-from models.enums import ApiTokenType-from models.model import ApiToken, App-from services.api_token_service import ApiTokenCache-from services.app_service import AppService--from . import console_ns-from .wraps import (- RBACPermission,- account_initialization_required,- edit_permission_required,- rbac_permission_required,- setup_required,- with_current_tenant_id,- with_current_user,+from controllers.console import console_ns+from controllers.console.flask_admission import console_account_admission+from controllers.console.wraps import RBACPermission+from extensions.ext_application_services import application_services+from fields.api_key_fields import ApiKeyItem, ApiKeyList, build_masked_api_key_list+from libs.helper import dump_response+from machinery.context import RequestContext+from models.account import TenantAccountRole+from services.agent.errors import AgentAccessNotReadyError+from services.app.api_key_service import AppApiKeyNotReadyError+from services.auth.api_key_contracts import (+ ApiKeyLimitExceededError,+ ApiKeyNotFoundError,+ ApiKeyResourceNotFoundError,)+from services.errors.account import NoPermissionError+from services.knowledge.api_key_service import UnknownDatasetIdsError--class ApiKeyItem(ResponseModel):- id: str- type: str- token: str- # Dataset keys only: the knowledge bases this key is bound to. Empty = the key can- # access every dataset in the tenant (default). App keys are always empty.- dataset_ids: list[str] = []- last_used_at: int | None = None- created_at: int | None = None-- @field_validator("last_used_at", "created_at", mode="before")- @classmethod- def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:- return to_timestamp(value)---class ApiKeyList(ResponseModel):- data: list[ApiKeyItem]-+API_KEY_EDIT_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR})+API_KEY_DELETE_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})register_response_schema_models(console_ns, ApiKeyItem, ApiKeyList)-def mask_api_token(token: str) -> str:- """Mask a secret token for list responses.-- Reveal-once: the full secret is only returned by the create endpoint. List- endpoints expose just enough (prefix + last 4) to identify a key, never the- full value, so an existing key's secret cannot be retrieved after creation.- """- if len(token) <= 8:- return "***"- return f"{token[:5]}...{token[-4:]}"---def build_masked_api_key_list(- api_tokens: Iterable[ApiToken],- bindings_by_token: Mapping[str, list[str]] | None = None,-) -> ApiKeyList:- """Build an ApiKeyList from ORM tokens with their secrets masked.-- ``bindings_by_token`` maps an api_token id to the dataset ids it is bound to- (from DatasetApiTokenBinding); tokens absent from the map are unbound (empty =- access all). App-key lists omit it entirely.- """- bindings_by_token = bindings_by_token or {}- items: list[ApiKeyItem] = []- for api_token in api_tokens:- item = ApiKeyItem.model_validate(api_token, from_attributes=True)- item.token = mask_api_token(item.token)- item.dataset_ids = bindings_by_token.get(str(api_token.id), [])- items.append(item)- return ApiKeyList(data=items)---def _get_resource(resource_id, tenant_id, resource_model, *, session: Session):- resource = session.execute(- select(resource_model).filter_by(id=resource_id, tenant_id=tenant_id)- ).scalar_one_or_none()-- if resource is None:- flask_restx.abort(HTTPStatus.NOT_FOUND, message=f"{resource_model.__name__} not found.")-- return resource---class BaseApiKeyListResource(Resource):- method_decorators = [account_initialization_required, login_required, setup_required]-- resource_type: ApiTokenType | None = None- resource_model: type | None = None- resource_id_field: str | None = None- token_prefix: str | None = None- max_keys = 10-- @with_session(write=False)- def get(self, session: Session, resource_id: str, current_tenant_id: str) -> dict[str, object]:- return dump_response(- ApiKeyList,- self._get_api_key_list(resource_id, current_tenant_id, session=session),- )-- def _get_api_key_list(self, resource_id: str, current_tenant_id: str, *, session: Session) -> ApiKeyList:- assert self.resource_id_field is not None, "resource_id_field must be set"-- _get_resource(resource_id, current_tenant_id, self.resource_model, session=session)- keys = session.scalars(- select(ApiToken).where(- or_(ApiToken.tenant_id == current_tenant_id, ApiToken.tenant_id.is_(None)),- ApiToken.type == self.resource_type,- getattr(ApiToken, self.resource_id_field) == resource_id,- )- ).all()- # App and agent keys keep their existing (unmasked) list behavior; reveal-once- # masking is scoped to dataset keys, which build their list in datasets.py.- return ApiKeyList(data=[ApiKeyItem.model_validate(key, from_attributes=True) for key in keys])-- @edit_permission_required- @with_session- def post(self, session: Session, resource_id: str, current_tenant_id: str) -> tuple[dict[str, object], int]:- return dump_response(- ApiKeyItem,- self._create_api_key(resource_id, current_tenant_id, session=session),- ), 201-- def _create_api_key(self, resource_id: str, current_tenant_id: str, *, session: Session) -> ApiToken:- assert self.resource_id_field is not None, "resource_id_field must be set"- resource = _get_resource(resource_id, current_tenant_id, self.resource_model, session=session)- if isinstance(resource, App):- AppService.ensure_agent_app_access_ready(resource, session=session)- current_key_count: int = (- session.scalar(- select(func.count(ApiToken.id)).where(- or_(ApiToken.tenant_id == current_tenant_id, ApiToken.tenant_id.is_(None)),- ApiToken.type == self.resource_type,- getattr(ApiToken, self.resource_id_field) == resource_id,- )- )- or 0- )-- if current_key_count >= self.max_keys:- flask_restx.abort(- HTTPStatus.BAD_REQUEST,- message=f"Cannot create more than {self.max_keys} API keys for this resource type.",- custom="max_keys_exceeded",- )-- key = ApiToken.generate_api_key(self.token_prefix or "", 24, session=session)- assert self.resource_type is not None, "resource_type must be set"- api_token = ApiToken()- setattr(api_token, self.resource_id_field, resource_id)- api_token.tenant_id = current_tenant_id- api_token.token = key- api_token.type = self.resource_type- session.add(api_token)- session.commit()- return api_token---class BaseApiKeyResource(Resource):- method_decorators = [account_initialization_required, login_required, setup_required]-- resource_type: ApiTokenType | None = None- resource_model: type | None = None- resource_id_field: str | None = None-- @with_session- def delete(- self,- session: Session,- resource_id: str,- api_key_id: str,- current_tenant_id: str,- current_user: Account,- ) -> tuple[str, int]:- self._delete_api_key(resource_id, api_key_id, current_tenant_id, current_user, session=session)- return "", 204-- def _delete_api_key(- self,- resource_id: str,- api_key_id: str,- current_tenant_id: str,- current_user: Account,- *,- session: Session,- ) -> None:- assert self.resource_id_field is not None, "resource_id_field must be set"- _get_resource(resource_id, current_tenant_id, self.resource_model, session=session)-- if not dify_config.RBAC_ENABLED and not current_user.is_admin_or_owner:- raise Forbidden()-- key = session.scalar(- select(ApiToken)- .where(- or_(ApiToken.tenant_id == current_tenant_id, ApiToken.tenant_id.is_(None)),- getattr(ApiToken, self.resource_id_field) == resource_id,- ApiToken.type == self.resource_type,- ApiToken.id == api_key_id,- )- .limit(1)- )-- if key is None:- flask_restx.abort(HTTPStatus.NOT_FOUND, message="API key not found")-- # Invalidate cache before deleting from database- # Type assertion: key is guaranteed to be non-None here because abort() raises- assert key is not None # nosec - for type checker only- ApiTokenCache.delete(key.token, key.type)-- session.delete(key)- session.commit()+@contextmanager+def api_key_errors() -> Generator[None]:+ """Translate application failures without changing the Console error contract."""+ try:+ yield+ except (ApiKeyResourceNotFoundError, ApiKeyNotFoundError) as error:+ flask_restx.abort(404, message=str(error))+ except ApiKeyLimitExceededError as error:+ flask_restx.abort(400, message=str(error), custom="max_keys_exceeded")+ except UnknownDatasetIdsError as error:+ flask_restx.abort(400, message=str(error))+ except NoPermissionError as error:+ flask_restx.abort(403, message=str(error))+ except AppApiKeyNotReadyError as error:+ raise AgentAccessNotReadyError from error@console_ns.route("/apps/<uuid:resource_id>/api-keys")-class AppApiKeyListResource(BaseApiKeyListResource):+class AppApiKeyListResource(Resource):@console_ns.doc("get_app_api_keys")@console_ns.doc(description="Get all API keys for an app")@console_ns.doc(params={"resource_id": "App ID"})@console_ns.response(200, "API keys retrieved successfully", console_ns.models[ApiKeyList.__name__])- @with_current_tenant_id- @edit_permission_required- @rbac_permission_required(- RBACCheck(RBACPermission.APP_RELEASE_AND_VERSION, PlainApp("resource_id")),- RBACCheck(RBACPermission.AGENT_ACCESS_POINT_VIEW, AgentBehindApp("resource_id")),+ @console_account_admission(+ allowed_roles=API_KEY_EDIT_ROLES,+ rbac_checks=[+ RBACCheck(RBACPermission.APP_RELEASE_AND_VERSION, PlainApp("resource_id")),+ RBACCheck(RBACPermission.AGENT_ACCESS_POINT_VIEW, AgentBehindApp("resource_id")),+ ],)- @with_session(write=False)- def get(self, session: Session, current_tenant_id: str, resource_id: UUID) -> dict[str, object]:- """Get all API keys for an app"""- return dump_response(- ApiKeyList,- self._get_api_key_list(str(resource_id), current_tenant_id, session=session), # pyrefly: ignore[unnecessary-type-conversion]- )+ def get(self, request_context: RequestContext, resource_id: UUID) -> dict[str, object]:+ with api_key_errors():+ keys = application_services().app_api_keys.list_keys(request_context, str(resource_id))+ return dump_response(ApiKeyList, {"data": keys})@console_ns.doc("create_app_api_key")@console_ns.doc(description="Create a new API key for an app")@console_ns.doc(params={"resource_id": "App ID"})@console_ns.response(201, "API key created successfully", console_ns.models[ApiKeyItem.__name__])@console_ns.response(400, "Maximum keys exceeded")- @with_current_tenant_id- @edit_permission_required- @rbac_permission_required(- RBACCheck(RBACPermission.APP_RELEASE_AND_VERSION, PlainApp("resource_id")),- RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentBehindApp("resource_id")),+ @console_account_admission(+ allowed_roles=API_KEY_EDIT_ROLES,+ rbac_checks=[+ RBACCheck(RBACPermission.APP_RELEASE_AND_VERSION, PlainApp("resource_id")),+ RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentBehindApp("resource_id")),+ ],)- @with_session- def post(self, session: Session, current_tenant_id: str, resource_id: UUID) -> tuple[dict[str, object], int]:- """Create a new API key for an app"""- return dump_response(- ApiKeyItem,- self._create_api_key(str(resource_id), current_tenant_id, session=session), # pyrefly: ignore[unnecessary-type-conversion]- ), 201-- resource_type = ApiTokenType.APP- resource_model = App- resource_id_field = "app_id"- token_prefix = "app-"+ def post(self, request_context: RequestContext, resource_id: UUID) -> tuple[dict[str, object], int]:+ with api_key_errors():+ key = application_services().app_api_keys.create_key(request_context, str(resource_id))+ return dump_response(ApiKeyItem, key), 201@console_ns.route("/apps/<uuid:resource_id>/api-keys/<uuid:api_key_id>")-class AppApiKeyResource(BaseApiKeyResource):+class AppApiKeyResource(Resource):@console_ns.doc("delete_app_api_key")@console_ns.doc(description="Delete an API key for an app")@console_ns.doc(params={"resource_id": "App ID", "api_key_id": "API key ID"})@console_ns.response(204, "API key deleted successfully")- @with_current_user- @with_current_tenant_id- @rbac_permission_required(- RBACCheck(RBACPermission.APP_RELEASE_AND_VERSION, PlainApp("resource_id")),- RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentBehindApp("resource_id")),+ @console_account_admission(+ allowed_roles=API_KEY_DELETE_ROLES,+ rbac_checks=[+ RBACCheck(RBACPermission.APP_RELEASE_AND_VERSION, PlainApp("resource_id")),+ RBACCheck(RBACPermission.AGENT_ACCESS_POINT_MANAGE, AgentBehindApp("resource_id")),+ ],)- @with_session- def delete(- self,- session: Session,- current_tenant_id: str,- current_user: Account,- resource_id: UUID,- api_key_id: UUID,- ) -> tuple[str, int]:- """Delete an API key for an app"""- self._delete_api_key(- str(resource_id), # pyrefly: ignore[unnecessary-type-conversion]- str(api_key_id),- current_tenant_id,- current_user,- session=session,- )+ def delete(self, request_context: RequestContext, resource_id: UUID, api_key_id: UUID) -> tuple[str, int]:+ with api_key_errors():+ application_services().app_api_keys.delete_key(request_context, str(resource_id), str(api_key_id))return "", 204- resource_type = ApiTokenType.APP- resource_model = App- resource_id_field = "app_id"--# Dataset service-API keys are also managed at the workspace level (create with a set of-# knowledge bases, list, delete) by DatasetApiKeyApi in-# controllers/console/datasets/datasets.py, using DatasetApiTokenBinding for scoping.-# The per-dataset routes below remain for callers that key an API token to a single dataset.@console_ns.route("/datasets/<uuid:resource_id>/api-keys")-class DatasetApiKeyListResource(BaseApiKeyListResource):+class DatasetApiKeyListResource(Resource):@console_ns.doc("get_dataset_api_keys")@console_ns.doc(description="Get all API keys for a dataset")@console_ns.doc(params={"resource_id": "Dataset ID"})@console_ns.response(200, "API keys retrieved successfully", console_ns.models[ApiKeyList.__name__])- @with_current_tenant_id- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, DatasetId("resource_id")))- @with_session(write=False)- def get(self, session: Session, current_tenant_id: str, resource_id: UUID) -> dict[str, object]:- """Get all API keys for a dataset"""- return dump_response(- ApiKeyList,- self._get_api_key_list(str(resource_id), current_tenant_id, session=session), # pyrefly: ignore[unnecessary-type-conversion]- )+ @console_account_admission(+ allowed_roles=API_KEY_EDIT_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, DatasetId("resource_id"))],+ )+ def get(self, request_context: RequestContext, resource_id: UUID) -> dict[str, object]:+ with api_key_errors():+ keys = application_services().dataset_api_keys.list_keys(request_context, str(resource_id))+ return dump_response(ApiKeyList, build_masked_api_key_list(keys))@console_ns.doc("create_dataset_api_key")@console_ns.doc(description="Create a new API key for a dataset")@console_ns.doc(params={"resource_id": "Dataset ID"})@console_ns.response(201, "API key created successfully", console_ns.models[ApiKeyItem.__name__])@console_ns.response(400, "Maximum keys exceeded")- @with_current_tenant_id- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, DatasetId("resource_id")))- @with_session- def post(self, session: Session, current_tenant_id: str, resource_id: UUID) -> tuple[dict[str, object], int]:- """Create a new API key for a dataset"""- return dump_response(- ApiKeyItem,- self._create_api_key(str(resource_id), current_tenant_id, session=session), # pyrefly: ignore[unnecessary-type-conversion]- ), 201-- resource_type = ApiTokenType.DATASET- resource_model = Dataset- resource_id_field = "dataset_id"- token_prefix = "ds-"+ @console_account_admission(+ allowed_roles=API_KEY_EDIT_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, DatasetId("resource_id"))],+ )+ def post(self, request_context: RequestContext, resource_id: UUID) -> tuple[dict[str, object], int]:+ with api_key_errors():+ key = application_services().dataset_api_keys.create_key(request_context, str(resource_id))+ return dump_response(ApiKeyItem, key), 201@console_ns.route("/datasets/<uuid:resource_id>/api-keys/<uuid:api_key_id>")-class DatasetApiKeyResource(BaseApiKeyResource):+class DatasetApiKeyResource(Resource):@console_ns.doc("delete_dataset_api_key")@console_ns.doc(description="Delete an API key for a dataset")@console_ns.doc(params={"resource_id": "Dataset ID", "api_key_id": "API key ID"})@console_ns.response(204, "API key deleted successfully")- @with_current_user- @with_current_tenant_id- @rbac_permission_required(RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, DatasetId("resource_id")))- @with_session- def delete(- self,- session: Session,- current_tenant_id: str,- current_user: Account,- resource_id: UUID,- api_key_id: UUID,- ) -> tuple[str, int]:- """Delete an API key for a dataset"""- self._delete_api_key(- str(resource_id), # pyrefly: ignore[unnecessary-type-conversion]- str(api_key_id),- current_tenant_id,- current_user,- session=session,- )+ @console_account_admission(+ allowed_roles=API_KEY_DELETE_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, DatasetId("resource_id"))],+ )+ def delete(self, request_context: RequestContext, resource_id: UUID, api_key_id: UUID) -> tuple[str, int]:+ with api_key_errors():+ application_services().dataset_api_keys.delete_key(request_context, str(resource_id), str(api_key_id))return "", 204-- resource_type = ApiTokenType.DATASET- resource_model = Dataset- resource_id_field = "dataset_id"diff --git a/api/controllers/console/datasets/datasets.py b/api/controllers/console/datasets/datasets.pyindex e06c85b0cd0..da39eb26b4e 100644--- a/api/controllers/console/datasets/datasets.py+++ b/api/controllers/console/datasets/datasets.py@@ -6,7 +6,7 @@ from uuid import UUIDfrom flask import requestfrom flask_restx import Resourcefrom pydantic import BaseModel, Field, field_validator, model_validator-from sqlalchemy import func, select+from sqlalchemy import selectfrom sqlalchemy.orm import Sessionfrom werkzeug.exceptions import Forbidden, NotFound@@ -17,15 +17,15 @@ from controllers.common.rbac import DatasetId, RBACCheck, Workspace, enforce_rbafrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_modelsfrom controllers.common.session import with_sessionfrom controllers.console import console_ns-from controllers.console.apikey import ApiKeyItem, ApiKeyList, build_masked_api_key_list+from controllers.console.apikey import API_KEY_DELETE_ROLES, api_key_errorsfrom controllers.console.app.error import ProviderNotInitializeErrorfrom controllers.console.datasets.error import DatasetInUseError, DatasetNameDuplicateError, IndexingEstimateError+from controllers.console.flask_admission import console_account_admissionfrom controllers.console.wraps import (RBACPermission,account_initialization_required,cloud_edition_billing_rate_limit_check,enterprise_license_required,- is_admin_or_owner_required,model_validate,rbac_permission_required,setup_required,@@ -41,6 +41,8 @@ from core.rag.extractor.entity.datasource_type import DatasourceTypefrom core.rag.extractor.entity.extract_setting import ExtractSetting, NotionInfo, WebsiteInfofrom core.rag.index_processor.constant.index_type import IndexTechniqueTypefrom core.rag.retrieval.retrieval_methods import RetrievalMethod+from extensions.ext_application_services import application_services+from fields.api_key_fields import ApiKeyItem, ApiKeyList, build_masked_api_key_listfrom fields.base import ResponseModelfrom fields.dataset_fields import (DatasetDetailResponse,@@ -52,12 +54,10 @@ from libs.helper import build_icon_url, dump_response, to_timestampfrom libs.login import login_requiredfrom libs.pagination import clamp_paginationfrom libs.url_utils import normalize_api_base_url-from models import Account, ApiToken, App, Dataset, Document, UploadFile+from machinery.context import RequestContext+from models import Account, App, Dataset, Document, UploadFilefrom models.dataset import DatasetPermission, DatasetPermissionEnum, DatasetQuery-from models.enums import ApiTokenTypefrom models.provider_ids import ModelProviderID-from services import dataset_api_key_service-from services.api_token_service import ApiTokenCachefrom services.app_service import AppServicefrom services.dataset_ref_service import DatasetRefServicefrom services.dataset_service import DatasetPermissionService, DatasetService, DocumentService@@ -1113,121 +1113,49 @@ class DatasetIndexingStatusApi(Resource):@console_ns.route("/datasets/api-keys")class DatasetApiKeyApi(Resource):- max_keys = 10- token_prefix = "dataset-"- resource_type = ApiTokenType.DATASET-@console_ns.doc("get_dataset_api_keys")@console_ns.doc(description="Get dataset API keys")@console_ns.response(200, "API keys retrieved successfully", console_ns.models[ApiKeyList.__name__])- @setup_required- @login_required- @is_admin_or_owner_required- @rbac_permission_required(RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, Workspace()))- @account_initialization_required- @with_current_tenant_id- @with_session(write=False)- def get(self, session: Session, current_tenant_id: str):- keys = session.scalars(- select(ApiToken).where(ApiToken.type == self.resource_type, ApiToken.tenant_id == current_tenant_id)- ).all()- token_ids = [str(key.id) for key in keys]- bindings_by_token = dataset_api_key_service.list_bindings_by_token(session, token_ids)- return dump_response(ApiKeyList, build_masked_api_key_list(keys, bindings_by_token))+ @console_account_admission(+ allowed_roles=API_KEY_DELETE_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, Workspace())],+ )+ def get(self, request_context: RequestContext):+ with api_key_errors():+ keys = application_services().dataset_api_keys.list_workspace_keys(request_context)+ return dump_response(ApiKeyList, build_masked_api_key_list(keys))@console_ns.expect(console_ns.models[DatasetApiKeyCreatePayload.__name__])@console_ns.response(200, "API key created successfully", console_ns.models[ApiKeyItem.__name__])@console_ns.response(400, "Maximum keys exceeded")- @setup_required- @login_required- @is_admin_or_owner_required- @rbac_permission_required(RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, Workspace()))- @account_initialization_required- @with_current_tenant_id- @with_session- def post(self, session: Session, current_tenant_id: str):- # Optional list of knowledge bases to scope the key to. Absent/empty => the key- # can access every dataset in the tenant (default). Duplicates are de-duplicated.+ @console_account_admission(+ allowed_roles=API_KEY_DELETE_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, Workspace())],+ )+ def post(self, request_context: RequestContext):+ # Preserve the optional scope and validation response of the workspace route.payload = request.get_json(silent=True) or {}raw_dataset_ids = payload.get("dataset_ids") or []if not isinstance(raw_dataset_ids, list) or any(not isinstance(item, str) for item in raw_dataset_ids):console_ns.abort(400, message="dataset_ids must be a list of strings.")- dataset_ids = list(dict.fromkeys(raw_dataset_ids))-- if dataset_ids:- unknown = dataset_api_key_service.find_unknown_dataset_ids(session, dataset_ids, current_tenant_id)- if unknown:- console_ns.abort(400, message=f"Unknown knowledge base id(s): {', '.join(unknown)}")-- current_key_count = (- session.scalar(- select(func.count(ApiToken.id)).where(- ApiToken.type == self.resource_type, ApiToken.tenant_id == current_tenant_id- )- )- or 0- )-- if current_key_count >= self.max_keys:- console_ns.abort(- 400,- message=f"Cannot create more than {self.max_keys} API keys for this resource type.",- custom="max_keys_exceeded",- )-- key = ApiToken.generate_api_key(self.token_prefix, 24, session=session)- api_token = ApiToken()- api_token.tenant_id = current_tenant_id- api_token.token = key- api_token.type = self.resource_type- session.add(api_token)- session.flush()- dataset_api_key_service.bind_datasets(session, api_token.id, dataset_ids)- session.flush()-- # Reveal-once: the create response carries the full secret and its bound scope.- item = ApiKeyItem.model_validate(api_token, from_attributes=True)- item.dataset_ids = dataset_ids- return dump_response(ApiKeyItem, item), 200+ with api_key_errors():+ key = application_services().dataset_api_keys.create_workspace_key(request_context, tuple(raw_dataset_ids))+ return dump_response(ApiKeyItem, key), 200@console_ns.route("/datasets/api-keys/<uuid:api_key_id>")class DatasetApiDeleteApi(Resource):- resource_type = ApiTokenType.DATASET-@console_ns.doc("delete_dataset_api_key")@console_ns.doc(description="Delete dataset API key")@console_ns.doc(params={"api_key_id": "API key ID"})@console_ns.response(204, "API key deleted successfully")- @setup_required- @login_required- @is_admin_or_owner_required- @rbac_permission_required(RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, Workspace()))- @account_initialization_required- @with_current_tenant_id- @with_session- def delete(self, session: Session, current_tenant_id: str, api_key_id: UUID):- api_key_id_str = str(api_key_id)- key = session.scalar(- select(ApiToken)- .where(- ApiToken.tenant_id == current_tenant_id,- ApiToken.type == self.resource_type,- ApiToken.id == api_key_id_str,- )- .limit(1)- )-- if key is None:- console_ns.abort(404, message="API key not found")-- # Invalidate cache before deleting from database- # Type assertion: key is guaranteed to be non-None here because abort() raises- assert key is not None # nosec - for type checker only- ApiTokenCache.delete(key.token, key.type)-- session.delete(key)-+ @console_account_admission(+ allowed_roles=API_KEY_DELETE_ROLES,+ rbac_checks=[RBACCheck(RBACPermission.DATASET_API_KEY_MANAGE, Workspace())],+ )+ def delete(self, request_context: RequestContext, api_key_id: UUID):+ with api_key_errors():+ application_services().dataset_api_keys.delete_workspace_key(request_context, str(api_key_id))return "", 204diff --git a/api/controllers/service_api/wraps.py b/api/controllers/service_api/wraps.pyindex 1b6192928f0..73cab1d068d 100644--- a/api/controllers/service_api/wraps.py+++ b/api/controllers/service_api/wraps.py@@ -30,7 +30,7 @@ from libs.login import current_userfrom models import Account, Tenant, TenantAccountJoin, TenantStatusfrom models.dataset import Dataset, RateLimitLogfrom models.model import ApiToken, App-from services import dataset_api_key_service+from repositories.knowledge import dataset_api_key_bindingsfrom services.api_token_service import ApiTokenCache, fetch_token_with_single_flight, record_token_usagefrom services.feature_service import FeatureService@@ -343,7 +343,7 @@ def validate_dataset_token[R](view: Callable[..., R]) -> Callable[..., R]:# per request (not cached) so scope changes take effect immediately.# db.session is Flask-SQLAlchemy's scoped_session proxy; cast so the plain-Session# typed helper accepts it (runtime proxies every Session method through unchanged).- bound_dataset_ids = dataset_api_key_service.get_bound_dataset_ids(cast(Session, db.session), api_token.id)+ bound_dataset_ids = dataset_api_key_bindings.get_bound_dataset_ids(cast(Session, db.session), api_token.id)if bound_dataset_ids and (not dataset_id or str(dataset_id) not in bound_dataset_ids):raise Forbidden("The API key is not authorized to access this knowledge base.")diff --git a/api/extensions/application_services/app.py b/api/extensions/application_services/app.pynew file mode 100644index 00000000000..b2faa315bd6--- /dev/null+++ b/api/extensions/application_services/app.py@@ -0,0 +1,14 @@+"""Compose App API access dependencies."""++from sqlalchemy.orm import Session, sessionmaker++from repositories.app.api_key_repository import AppApiKeyRepository+from services.api_token_service import ApiTokenCache+from services.app.api_key_service import AppApiKeyService+++def build_app_api_key_service(*, database_client: sessionmaker[Session]) -> AppApiKeyService:+ return AppApiKeyService(+ keys=AppApiKeyRepository(session_factory=database_client),+ cache=ApiTokenCache,+ )diff --git a/api/extensions/application_services/knowledge.py b/api/extensions/application_services/knowledge.pynew file mode 100644index 00000000000..e3300814ae3--- /dev/null+++ b/api/extensions/application_services/knowledge.py@@ -0,0 +1,16 @@+"""Composition of knowledge base application services."""++from sqlalchemy.orm import Session, sessionmaker++from configs import dify_config+from repositories.knowledge.dataset_api_key_repository import DatasetApiKeyRepository+from services.api_token_service import ApiTokenCache+from services.knowledge.api_key_service import DatasetApiKeyService+++def build_dataset_api_key_service(*, database_client: sessionmaker[Session]) -> DatasetApiKeyService:+ return DatasetApiKeyService(+ keys=DatasetApiKeyRepository(session_factory=database_client),+ cache=ApiTokenCache,+ rbac_enabled=lambda: dify_config.RBAC_ENABLED,+ )diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 5fc8e6be954..67f8caa1f45 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -23,6 +23,8 @@ from core.schemas.schema_manager import SchemaManagerfrom core.tools.tool_file_manager import ToolFileManagerfrom enums import DeploymentEdition, WebAppAccessModefrom extensions.application_services.agent import AgentAppServices, build_agent_app_services+from extensions.application_services.app import build_app_api_key_service+from extensions.application_services.knowledge import build_dataset_api_key_servicefrom extensions.ext_redis import RedisClientWrapper, redis_clientfrom extensions.ext_storage import storagefrom libs.datetime_utils import naive_utc_now, utc_now@@ -143,6 +145,7 @@ from services.account_password_hasher import DefaultAccountPasswordHasherfrom services.account_password_service import AccountPasswordServicefrom services.account_profile_service import AccountProfileServicefrom services.app.advanced_prompt_template_service import AdvancedPromptTemplateService+from services.app.api_key_service import AppApiKeyServicefrom services.app_audio_adapters import AppAudioRuntimefrom services.app_audio_service import AppAudiofrom services.app_definition_query_service import AppDefinitionQueryService@@ -180,6 +183,7 @@ from services.inner_mail_service import InnerMailServicefrom services.installed_app_access_service import InstalledAppAccessServicefrom services.installed_app_generation_adapters import AppGenerateServiceRuntime as InstalledAppGenerateServiceRuntimefrom services.installed_app_generation_service import InstalledAppGenerationService+from services.knowledge.api_key_service import DatasetApiKeyServicefrom services.message_file_preview_service import MessageFilePreviewServicefrom services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntimefrom services.message_suggested_questions_service import MessageSuggestedQuestions@@ -298,6 +302,8 @@ class ApplicationServices:agent_apps: AgentAppServicesadvanced_prompt_templates: AdvancedPromptTemplateServiceaccounts: AccountServices+ app_api_keys: AppApiKeyService+ dataset_api_keys: DatasetApiKeyServiceaccount_activation: AccountActivationServiceapp_definitions: AppDefinitionQueryServiceapp_preview_details: AppPreviewDetails@@ -717,6 +723,8 @@ def build_application_services(app_sites=AppSiteService(sites=AppSiteCommandRepository(session_factory=database_client),),+ app_api_keys=build_app_api_key_service(database_client=database_client),+ dataset_api_keys=build_dataset_api_key_service(database_client=database_client),app_statistics=AppStatisticQueryRepository(session_factory=database_client),app_tracing_configs=AppTracingConfigService(configs=SQLAlchemyAppTracingConfigRepository(session_factory=database_client),diff --git a/api/fields/api_key_fields.py b/api/fields/api_key_fields.pynew file mode 100644index 00000000000..f8919d22d50--- /dev/null+++ b/api/fields/api_key_fields.py@@ -0,0 +1,61 @@+"""Response contracts shared by Console API key endpoints."""++from collections.abc import Iterable, Mapping+from datetime import datetime++from pydantic import field_validator++from fields.base import ResponseModel+from libs.helper import to_timestamp+++class ApiKeyItem(ResponseModel):+ id: str+ type: str+ token: str+ # Dataset keys only: the knowledge bases this key is bound to. Empty = the key can+ # access every dataset in the tenant (default). App keys are always empty.+ dataset_ids: list[str] = []+ last_used_at: int | None = None+ created_at: int | None = None++ @field_validator("last_used_at", "created_at", mode="before")+ @classmethod+ def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:+ return to_timestamp(value)+++class ApiKeyList(ResponseModel):+ data: list[ApiKeyItem]+++def mask_api_token(token: str) -> str:+ """Mask a secret token for list responses.++ Reveal-once: the full secret is only returned by the create endpoint. List+ endpoints expose just enough (prefix + last 4) to identify a key, never the+ full value, so an existing key's secret cannot be retrieved after creation.+ """+ if len(token) <= 8:+ return "***"+ return f"{token[:5]}...{token[-4:]}"+++def build_masked_api_key_list(+ api_tokens: Iterable[object],+ bindings_by_token: Mapping[str, list[str]] | None = None,+) -> ApiKeyList:+ """Build an ApiKeyList from token records with their secrets masked.++ ``bindings_by_token`` maps an api_token id to the dataset ids it is bound to+ (from DatasetApiTokenBinding); tokens absent from the map are unbound (empty =+ access all). When omitted, preserve the scope carried by the records.+ """+ items: list[ApiKeyItem] = []+ for api_token in api_tokens:+ item = ApiKeyItem.model_validate(api_token, from_attributes=True)+ item.token = mask_api_token(item.token)+ if bindings_by_token is not None:+ item.dataset_ids = bindings_by_token.get(item.id, [])+ items.append(item)+ return ApiKeyList(data=items)diff --git a/api/models/model.py b/api/models/model.pyindex 3280f46fa41..287f8bbca96 100644--- a/api/models/model.py+++ b/api/models/model.py@@ -2236,9 +2236,6 @@ class ApiToken(Base):key with binding rows is limited to exactly those datasets). Enforcement lives in``validate_dataset_token`` (controllers/service_api/wraps.py).- Note: controllers/console/apikey.py assigns the ``*_id`` columns via ``setattr``- keyed on ``resource_id_field``, so renaming ``app_id`` requires updating those- controllers too."""__tablename__ = "api_tokens"diff --git a/api/openapi/markdown/console-openapi.md b/api/openapi/markdown/console-openapi.mdindex e0b55141371..d484d62fa21 100644--- a/api/openapi/markdown/console-openapi.md+++ b/api/openapi/markdown/console-openapi.md@@ -4807,7 +4807,7 @@ Restore a published workflow version into the draft workflow| 404 | Workflow not found | |### [GET] /apps/{resource_id}/api-keys-**Get all API keys for an app**+Get all API keys for an app#### Parameters@@ -4822,7 +4822,7 @@ Restore a published workflow version into the draft workflow| 200 | API keys retrieved successfully | **application/json**: [ApiKeyList](#apikeylist)<br> |### [POST] /apps/{resource_id}/api-keys-**Create a new API key for an app**+Create a new API key for an app#### Parameters@@ -4838,7 +4838,7 @@ Restore a published workflow version into the draft workflow| 400 | Maximum keys exceeded | |### [DELETE] /apps/{resource_id}/api-keys/{api_key_id}-**Delete an API key for an app**+Delete an API key for an app#### Parameters@@ -6447,7 +6447,7 @@ Check if dataset is in use| 200 | Dataset use status retrieved successfully | **application/json**: [UsageCheckResponse](#usagecheckresponse)<br> |### [GET] /datasets/{resource_id}/api-keys-**Get all API keys for a dataset**+Get all API keys for a dataset#### Parameters@@ -6462,7 +6462,7 @@ Check if dataset is in use| 200 | API keys retrieved successfully | **application/json**: [ApiKeyList](#apikeylist)<br> |### [POST] /datasets/{resource_id}/api-keys-**Create a new API key for a dataset**+Create a new API key for a dataset#### Parameters@@ -6478,7 +6478,7 @@ Check if dataset is in use| 400 | Maximum keys exceeded | |### [DELETE] /datasets/{resource_id}/api-keys/{api_key_id}-**Delete an API key for a dataset**+Delete an API key for a dataset#### Parametersdiff --git a/api/repositories/app/api_key_repository.py b/api/repositories/app/api_key_repository.pynew file mode 100644index 00000000000..7fd20ad8eff--- /dev/null+++ b/api/repositories/app/api_key_repository.py@@ -0,0 +1,124 @@+"""App API keys with tenant scoping and repository-owned transactions."""++from typing import override++from sqlalchemy import Select, func, or_, select+from sqlalchemy.orm import Session, sessionmaker++from core.agent.publish_visibility import workflow_callable_active_snapshot_filter+from models.agent import APP_BACKED_AGENT_SOURCES, Agent, AgentScope, AgentStatus+from models.enums import ApiTokenType, AppStatus+from models.model import ApiToken, App, AppMode+from services.app.api_key_service import AppApiKeyAccessState, AppApiKeyStore+from services.auth.api_key_contracts import (+ ApiKeyLimitExceededError,+ ApiKeyNotFoundError,+ ApiKeyRecord,+ ApiKeyResourceNotFoundError,+)+++class AppApiKeyRepository(AppApiKeyStore):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def resolve_agent_app_id(self, workspace_id: str, agent_id: str) -> str:+ with self._session_factory() as session:+ app_id = session.scalar(+ select(App.id)+ .join(Agent, Agent.app_id == App.id)+ .where(+ App.tenant_id == workspace_id,+ App.mode == AppMode.AGENT,+ App.status == AppStatus.NORMAL,+ Agent.tenant_id == workspace_id,+ Agent.id == agent_id,+ Agent.scope == AgentScope.ROSTER,+ Agent.source.in_(APP_BACKED_AGENT_SOURCES),+ Agent.status == AgentStatus.ACTIVE,+ )+ )+ if app_id is None:+ raise ApiKeyResourceNotFoundError("Agent not found.")+ return app_id++ @override+ def get_access_state(self, workspace_id: str, app_id: str) -> AppApiKeyAccessState:+ with self._session_factory() as session:+ app = self._get_app(session, workspace_id, app_id)+ if app.mode != AppMode.AGENT:+ return AppApiKeyAccessState(is_agent_app=False, has_published_snapshot=False)+ published = session.scalar(+ select(Agent.id)+ .where(+ Agent.tenant_id == workspace_id,+ Agent.app_id == app_id,+ Agent.scope == AgentScope.ROSTER,+ Agent.source.in_(APP_BACKED_AGENT_SOURCES),+ Agent.status == AgentStatus.ACTIVE,+ workflow_callable_active_snapshot_filter(),+ )+ .limit(1)+ )+ return AppApiKeyAccessState(is_agent_app=True, has_published_snapshot=published is not None)++ @override+ def list_keys(self, workspace_id: str, app_id: str) -> tuple[ApiKeyRecord, ...]:+ with self._session_factory() as session:+ self._get_app(session, workspace_id, app_id)+ return tuple(self._record(key) for key in session.scalars(self._key_query(workspace_id, app_id)))++ @override+ def create_key(self, workspace_id: str, app_id: str, *, max_keys: int, prefix: str) -> ApiKeyRecord:+ with self._session_factory.begin() as session:+ # Serialize count-and-insert for the App, including historical keys.+ self._get_app(session, workspace_id, app_id, for_update=True)+ count = session.scalar(select(func.count()).select_from(self._key_query(workspace_id, app_id).subquery()))+ if count is not None and count >= max_keys:+ raise ApiKeyLimitExceededError(max_keys)+ key = ApiToken(+ tenant_id=workspace_id,+ app_id=app_id,+ type=ApiTokenType.APP,+ token=ApiToken.generate_api_key(prefix, 24, session=session),+ )+ session.add(key)+ session.flush()+ return self._record(key)++ @override+ def delete_key(self, workspace_id: str, app_id: str, key_id: str) -> ApiKeyRecord:+ with self._session_factory.begin() as session:+ self._get_app(session, workspace_id, app_id)+ key = session.scalar(self._key_query(workspace_id, app_id).where(ApiToken.id == key_id))+ if key is None:+ raise ApiKeyNotFoundError+ record = self._record(key)+ session.delete(key)+ return record++ @staticmethod+ def _get_app(session: Session, workspace_id: str, app_id: str, *, for_update: bool = False) -> App:+ query = select(App).where(App.id == app_id, App.tenant_id == workspace_id)+ if for_update:+ query = query.with_for_update()+ app = session.scalar(query)+ if app is None:+ raise ApiKeyResourceNotFoundError("App not found.")+ return app++ @staticmethod+ def _key_query(workspace_id: str, app_id: str) -> Select[tuple[ApiToken]]:+ # Historical keys have no tenant_id; the owning App is validated first.+ return select(ApiToken).where(+ or_(ApiToken.tenant_id == workspace_id, ApiToken.tenant_id.is_(None)),+ ApiToken.type == ApiTokenType.APP,+ ApiToken.app_id == app_id,+ )++ @staticmethod+ def _record(key: ApiToken) -> ApiKeyRecord:+ return ApiKeyRecord(+ id=key.id, type=key.type, token=key.token, last_used_at=key.last_used_at, created_at=key.created_at+ )diff --git a/api/repositories/knowledge/__init__.py b/api/repositories/knowledge/__init__.pynew file mode 100644index 00000000000..2ba7ed3f45b--- /dev/null+++ b/api/repositories/knowledge/__init__.py@@ -0,0 +1 @@+"""Knowledge base persistence and queries."""diff --git a/api/services/dataset_api_key_service.py b/api/repositories/knowledge/dataset_api_key_bindings.pysimilarity index 82%rename from api/services/dataset_api_key_service.pyrename to api/repositories/knowledge/dataset_api_key_bindings.pyindex 608bf3ef632..68192c376ce 100644--- a/api/services/dataset_api_key_service.py+++ b/api/repositories/knowledge/dataset_api_key_bindings.py@@ -6,14 +6,13 @@ A dataset API key is scoped to specific knowledge bases through- no rows -> the key can access every dataset in its tenant (default / back-compat)- N rows -> the key is restricted to exactly those datasets-These helpers live in the service layer so controllers and the service-API auth-decorator can share the queries without embedding SQLAlchemy in controller code.+Shared by key management, dataset deletion, and service-API authentication.The caller owns the transaction boundary (commit/flush)."""from collections.abc import Iterable-from sqlalchemy import delete, select+from sqlalchemy import Select, delete, selectfrom sqlalchemy.orm import Sessionfrom models.dataset import Dataset@@ -77,18 +76,17 @@ def delete_keys_scoped_only_to(session: Session, dataset_id: str) -> list[str]:Must run before the dataset row is deleted (so the bindings still exist).Returns the deleted api_token ids; the caller controls the transaction."""- orphan_ids = [- str(token_id)- for token_id in session.scalars(- select(DatasetApiTokenBinding.api_token_id)- .where(DatasetApiTokenBinding.dataset_id == dataset_id)- .where(- DatasetApiTokenBinding.api_token_id.notin_(- select(DatasetApiTokenBinding.api_token_id).where(DatasetApiTokenBinding.dataset_id != dataset_id)- )- )- ).all()- ]+ orphan_ids = [str(token_id) for token_id in session.scalars(token_ids_scoped_only_to(dataset_id)).all()]if orphan_ids:session.execute(delete(ApiToken).where(ApiToken.id.in_(orphan_ids)))return orphan_ids+++def token_ids_scoped_only_to(dataset_id: str) -> Select[tuple[str]]:+ """Select keys bound only to one dataset, for management and deletion."""+ return select(DatasetApiTokenBinding.api_token_id).where(+ DatasetApiTokenBinding.dataset_id == dataset_id,+ DatasetApiTokenBinding.api_token_id.notin_(+ select(DatasetApiTokenBinding.api_token_id).where(DatasetApiTokenBinding.dataset_id != dataset_id)+ ),+ )diff --git a/api/repositories/knowledge/dataset_api_key_repository.py b/api/repositories/knowledge/dataset_api_key_repository.pynew file mode 100644index 00000000000..0dd1264eced--- /dev/null+++ b/api/repositories/knowledge/dataset_api_key_repository.py@@ -0,0 +1,156 @@+"""Knowledge base API keys with repository-owned sessions and transactions."""++from typing import override++from sqlalchemy import Select, func, select+from sqlalchemy.orm import Session, sessionmaker++from models.account import Tenant, TenantAccountJoin+from models.dataset import Dataset, DatasetPermission+from models.enums import ApiTokenType+from models.model import ApiToken+from repositories.knowledge import dataset_api_key_bindings+from services.auth.api_key_contracts import (+ ApiKeyLimitExceededError,+ ApiKeyNotFoundError,+ ApiKeyRecord,+ ApiKeyResourceNotFoundError,+)+from services.knowledge.api_key_service import DatasetApiKeyStore, UnknownDatasetIdsError+from services.knowledge.dataset_access import DatasetAccess+++class DatasetApiKeyRepository(DatasetApiKeyStore):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def get_dataset_access(self, workspace_id: str, dataset_id: str, account_id: str) -> DatasetAccess:+ with self._session_factory() as session:+ dataset = self._get_dataset(session, workspace_id, dataset_id)+ role = session.scalar(+ select(TenantAccountJoin.role).where(+ TenantAccountJoin.tenant_id == workspace_id, TenantAccountJoin.account_id == account_id+ )+ )+ has_permission = (+ session.scalar(+ select(DatasetPermission.id)+ .where(+ DatasetPermission.tenant_id == workspace_id,+ DatasetPermission.dataset_id == dataset_id,+ DatasetPermission.account_id == account_id,+ DatasetPermission.has_permission.is_(True),+ )+ .limit(1)+ )+ is not None+ )+ return DatasetAccess(dataset.permission, dataset.maintainer, role, has_permission)++ @override+ def list_keys(self, workspace_id: str, dataset_id: str) -> tuple[ApiKeyRecord, ...]:+ with self._session_factory() as session:+ self._get_dataset(session, workspace_id, dataset_id)+ return tuple(+ self._record(key, (dataset_id,)) for key in session.scalars(self._key_query(workspace_id, dataset_id))+ )++ @override+ def create_key(self, workspace_id: str, dataset_id: str, *, max_keys: int, prefix: str) -> ApiKeyRecord:+ with self._session_factory.begin() as session:+ self._lock_workspace(session, workspace_id)+ self._get_dataset(session, workspace_id, dataset_id)+ return self._create_key(session, workspace_id, (dataset_id,), max_keys=max_keys, prefix=prefix)++ @override+ def list_workspace_keys(self, workspace_id: str) -> tuple[ApiKeyRecord, ...]:+ with self._session_factory() as session:+ keys = session.scalars(self._workspace_key_query(workspace_id)).all()+ bindings = dataset_api_key_bindings.list_bindings_by_token(session, (key.id for key in keys))+ return tuple(self._record(key, tuple(bindings.get(key.id, ()))) for key in keys)++ @override+ def create_workspace_key(+ self, workspace_id: str, dataset_ids: tuple[str, ...], *, max_keys: int, prefix: str+ ) -> ApiKeyRecord:+ with self._session_factory.begin() as session:+ self._lock_workspace(session, workspace_id)+ unknown = dataset_api_key_bindings.find_unknown_dataset_ids(session, list(dataset_ids), workspace_id)+ if unknown:+ raise UnknownDatasetIdsError(unknown)+ return self._create_key(session, workspace_id, dataset_ids, max_keys=max_keys, prefix=prefix)++ @override+ def delete_workspace_key(self, workspace_id: str, key_id: str) -> ApiKeyRecord:+ with self._session_factory.begin() as session:+ key = session.scalar(self._workspace_key_query(workspace_id).where(ApiToken.id == key_id))+ if key is None:+ raise ApiKeyNotFoundError+ bindings = dataset_api_key_bindings.get_bound_dataset_ids(session, key.id)+ record = self._record(key, tuple(sorted(bindings)))+ session.delete(key)+ return record++ def _create_key(+ self, session: Session, workspace_id: str, dataset_ids: tuple[str, ...], *, max_keys: int, prefix: str+ ) -> ApiKeyRecord:+ count = session.scalar(select(func.count()).select_from(self._workspace_key_query(workspace_id).subquery()))+ if count is not None and count >= max_keys:+ raise ApiKeyLimitExceededError(max_keys)+ key = ApiToken(+ tenant_id=workspace_id,+ type=ApiTokenType.DATASET,+ token=ApiToken.generate_api_key(prefix, 24, session=session),+ )+ session.add(key)+ session.flush()+ dataset_api_key_bindings.bind_datasets(session, key.id, dataset_ids)+ return self._record(key, dataset_ids)++ @staticmethod+ def _lock_workspace(session: Session, workspace_id: str) -> None:+ # Both creation routes lock the same row before counting all workspace dataset keys.+ if session.scalar(select(Tenant.id).where(Tenant.id == workspace_id).with_for_update()) is None:+ raise ApiKeyResourceNotFoundError("Workspace not found.")++ @override+ def delete_key(self, workspace_id: str, dataset_id: str, key_id: str) -> ApiKeyRecord:+ with self._session_factory.begin() as session:+ self._get_dataset(session, workspace_id, dataset_id)+ key = session.scalar(self._key_query(workspace_id, dataset_id).where(ApiToken.id == key_id))+ if key is None:+ raise ApiKeyNotFoundError+ record = self._record(key, (dataset_id,))+ session.delete(key)+ return record++ @staticmethod+ def _get_dataset(session: Session, workspace_id: str, dataset_id: str) -> Dataset:+ query = select(Dataset).where(Dataset.id == dataset_id, Dataset.tenant_id == workspace_id)+ dataset = session.scalar(query)+ if dataset is None:+ raise ApiKeyResourceNotFoundError("Dataset not found.")+ return dataset++ @staticmethod+ def _workspace_key_query(workspace_id: str) -> Select[tuple[ApiToken]]:+ return select(ApiToken).where(ApiToken.tenant_id == workspace_id, ApiToken.type == ApiTokenType.DATASET)++ @classmethod+ def _key_query(cls, workspace_id: str, dataset_id: str) -> Select[tuple[ApiToken]]:+ # A per-dataset permission cannot expose or revoke broader workspace keys.+ return cls._workspace_key_query(workspace_id).where(+ ApiToken.id.in_(dataset_api_key_bindings.token_ids_scoped_only_to(dataset_id)),+ )++ @staticmethod+ def _record(key: ApiToken, dataset_ids: tuple[str, ...]) -> ApiKeyRecord:+ return ApiKeyRecord(+ id=key.id,+ type=key.type,+ token=key.token,+ last_used_at=key.last_used_at,+ created_at=key.created_at,+ dataset_ids=dataset_ids,+ )diff --git a/api/services/app/api_key_service.py b/api/services/app/api_key_service.pynew file mode 100644index 00000000000..a34c043bee6--- /dev/null+++ b/api/services/app/api_key_service.py@@ -0,0 +1,61 @@+"""Manage App API access, including Agent routes backed by an App."""++from dataclasses import dataclass+from typing import Protocol++from machinery.context import RequestContext+from services.auth.api_key_contracts import ApiKeyCache, ApiKeyRecord+++@dataclass(frozen=True, slots=True)+class AppApiKeyAccessState:+ is_agent_app: bool+ has_published_snapshot: bool+++class AppApiKeyStore(Protocol):+ def resolve_agent_app_id(self, workspace_id: str, agent_id: str) -> str: ...++ def get_access_state(self, workspace_id: str, app_id: str) -> AppApiKeyAccessState: ...++ def list_keys(self, workspace_id: str, app_id: str) -> tuple[ApiKeyRecord, ...]: ...++ def create_key(self, workspace_id: str, app_id: str, *, max_keys: int, prefix: str) -> ApiKeyRecord: ...++ def delete_key(self, workspace_id: str, app_id: str, key_id: str) -> ApiKeyRecord: ...+++class AppApiKeyNotReadyError(Exception):+ pass+++class AppApiKeyService:+ def __init__(self, *, keys: AppApiKeyStore, cache: ApiKeyCache) -> None:+ self._keys = keys+ self._cache = cache++ def list_keys(self, context: RequestContext, app_id: str) -> tuple[ApiKeyRecord, ...]:+ return self._keys.list_keys(context.active_workspace_id, app_id)++ def create_key(self, context: RequestContext, app_id: str) -> ApiKeyRecord:+ access = self._keys.get_access_state(context.active_workspace_id, app_id)+ if access.is_agent_app and not access.has_published_snapshot:+ raise AppApiKeyNotReadyError+ return self._keys.create_key(context.active_workspace_id, app_id, max_keys=10, prefix="app-")++ def delete_key(self, context: RequestContext, app_id: str, key_id: str) -> None:+ key = self._keys.delete_key(context.active_workspace_id, app_id, key_id)+ # External cache I/O follows the repository's committed transaction.+ self._cache.delete(key.token, key.type)++ def list_agent_keys(self, context: RequestContext, agent_id: str) -> tuple[ApiKeyRecord, ...]:+ app_id = self._keys.resolve_agent_app_id(context.active_workspace_id, agent_id)+ return self.list_keys(context, app_id)++ def create_agent_key(self, context: RequestContext, agent_id: str) -> ApiKeyRecord:+ app_id = self._keys.resolve_agent_app_id(context.active_workspace_id, agent_id)+ return self.create_key(context, app_id)++ def delete_agent_key(self, context: RequestContext, agent_id: str, key_id: str) -> None:+ app_id = self._keys.resolve_agent_app_id(context.active_workspace_id, agent_id)+ self.delete_key(context, app_id, key_id)diff --git a/api/services/auth/api_key_contracts.py b/api/services/auth/api_key_contracts.pynew file mode 100644index 00000000000..e6dbf661221--- /dev/null+++ b/api/services/auth/api_key_contracts.py@@ -0,0 +1,33 @@+"""Framework-neutral data contracts for API key management."""++from dataclasses import dataclass+from datetime import datetime+from typing import Protocol+++@dataclass(frozen=True, slots=True)+class ApiKeyRecord:+ id: str+ type: str+ token: str+ last_used_at: datetime | None = None+ created_at: datetime | None = None+ dataset_ids: tuple[str, ...] = ()+++class ApiKeyCache(Protocol):+ def delete(self, token: str, scope: str | None = None) -> bool | None: ...+++class ApiKeyResourceNotFoundError(Exception):+ pass+++class ApiKeyNotFoundError(Exception):+ def __init__(self) -> None:+ super().__init__("API key not found")+++class ApiKeyLimitExceededError(Exception):+ def __init__(self, max_keys: int) -> None:+ super().__init__(f"Cannot create more than {max_keys} API keys for this resource type.")diff --git a/api/services/dataset_service.py b/api/services/dataset_service.pyindex e5c29958574..a0a0344c5e7 100644--- a/api/services/dataset_service.py+++ b/api/services/dataset_service.py@@ -64,7 +64,7 @@ from models.model import UploadFilefrom models.provider_ids import ModelProviderIDfrom models.source import DataSourceOauthBindingfrom models.workflow import Workflow-from services import dataset_api_key_service+from repositories.knowledge import dataset_api_key_bindingsfrom services.dataset_ref_service import DatasetRef, DatasetRefService, SegmentReffrom services.document_indexing_proxy.document_indexing_task_proxy import DocumentIndexingTaskProxyfrom services.document_indexing_proxy.duplicate_document_indexing_task_proxy import DuplicateDocumentIndexingTaskProxy@@ -89,6 +89,7 @@ from services.errors.file import FileNotExistsErrorfrom services.external_knowledge_service import ExternalDatasetServicefrom services.feature_service import FeatureServicefrom services.file_service import FileService+from services.knowledge.dataset_access import DatasetAccessfrom services.rag_pipeline.rag_pipeline import RagPipelineServicefrom services.tag_service import TagServicefrom services.vector_service import VectorService@@ -1363,7 +1364,7 @@ class DatasetService:# Remove any dataset API key scoped only to this knowledge base, so it cannot# silently degrade to unrestricted (access-all) once its last binding is gone.- dataset_api_key_service.delete_keys_scoped_only_to(session, str(dataset.id))+ dataset_api_key_bindings.delete_keys_scoped_only_to(session, str(dataset.id))session.delete(dataset)session.commit()@@ -1380,25 +1381,29 @@ class DatasetService:if dataset.tenant_id != user.current_tenant_id:logger.debug("User %s does not have permission to access dataset %s", user.id, dataset.id)raise NoPermissionError("You do not have permission to access this dataset.")- if user.current_role != TenantAccountRole.OWNER:- if dataset.permission == DatasetPermissionEnum.ONLY_ME and dataset.maintainer != user.id:- logger.debug("User %s does not have permission to access dataset %s", user.id, dataset.id)- raise NoPermissionError("You do not have permission to access this dataset.")- if dataset.permission == DatasetPermissionEnum.PARTIAL_TEAM:- # For partial team permission, user needs explicit permission or be the maintainer.- if dataset.maintainer != user.id:- user_permission = session.scalar(- select(DatasetPermission)- .where(- DatasetPermission.dataset_id == dataset.id,- DatasetPermission.account_id == user.id,- DatasetPermission.tenant_id == dataset.tenant_id,- )- .limit(1)+ has_permission = False+ if (+ user.current_role != TenantAccountRole.OWNER+ and dataset.permission == DatasetPermissionEnum.PARTIAL_TEAM+ and dataset.maintainer != user.id+ ):+ has_permission = (+ session.scalar(+ select(DatasetPermission.id)+ .where(+ DatasetPermission.dataset_id == dataset.id,+ DatasetPermission.account_id == user.id,+ DatasetPermission.tenant_id == dataset.tenant_id,+ DatasetPermission.has_permission.is_(True),)- if not user_permission:- logger.debug("User %s does not have permission to access dataset %s", user.id, dataset.id)- raise NoPermissionError("You do not have permission to access this dataset.")+ .limit(1)+ )+ is not None+ )+ access = DatasetAccess(dataset.permission, dataset.maintainer, user.current_role, has_permission)+ if not access.allows(user.id):+ logger.debug("User %s does not have permission to access dataset %s", user.id, dataset.id)+ raise NoPermissionError("You do not have permission to access this dataset.")@staticmethoddef check_dataset_operator_permission(diff --git a/api/services/knowledge/__init__.py b/api/services/knowledge/__init__.pynew file mode 100644index 00000000000..b1ff0725e7a--- /dev/null+++ b/api/services/knowledge/__init__.py@@ -0,0 +1 @@+"""Knowledge base application services."""diff --git a/api/services/knowledge/api_key_service.py b/api/services/knowledge/api_key_service.pynew file mode 100644index 00000000000..f03aad1f1ff--- /dev/null+++ b/api/services/knowledge/api_key_service.py@@ -0,0 +1,73 @@+"""Manage workspace knowledge API keys and keys restricted to one knowledge base."""++from collections.abc import Callable+from typing import Protocol++from machinery.context import RequestContext+from services.auth.api_key_contracts import ApiKeyCache, ApiKeyRecord+from services.errors.account import NoPermissionError+from services.knowledge.dataset_access import DatasetAccess+++class DatasetApiKeyStore(Protocol):+ def get_dataset_access(self, workspace_id: str, dataset_id: str, account_id: str) -> DatasetAccess: ...++ def list_keys(self, workspace_id: str, dataset_id: str) -> tuple[ApiKeyRecord, ...]: ...++ def create_key(self, workspace_id: str, dataset_id: str, *, max_keys: int, prefix: str) -> ApiKeyRecord: ...++ def delete_key(self, workspace_id: str, dataset_id: str, key_id: str) -> ApiKeyRecord: ...++ def list_workspace_keys(self, workspace_id: str) -> tuple[ApiKeyRecord, ...]: ...++ def create_workspace_key(+ self, workspace_id: str, dataset_ids: tuple[str, ...], *, max_keys: int, prefix: str+ ) -> ApiKeyRecord: ...++ def delete_workspace_key(self, workspace_id: str, key_id: str) -> ApiKeyRecord: ...+++class UnknownDatasetIdsError(Exception):+ def __init__(self, dataset_ids: list[str]) -> None:+ super().__init__(f"Unknown knowledge base id(s): {', '.join(dataset_ids)}")+++class DatasetApiKeyService:+ MAX_KEYS = 10++ def __init__(self, *, keys: DatasetApiKeyStore, cache: ApiKeyCache, rbac_enabled: Callable[[], bool]) -> None:+ self._keys = keys+ self._cache = cache+ self._rbac_enabled = rbac_enabled++ def list_keys(self, context: RequestContext, dataset_id: str) -> tuple[ApiKeyRecord, ...]:+ self._check_access(context, dataset_id)+ return self._keys.list_keys(context.active_workspace_id, dataset_id)++ def create_key(self, context: RequestContext, dataset_id: str) -> ApiKeyRecord:+ self._check_access(context, dataset_id)+ return self._keys.create_key(context.active_workspace_id, dataset_id, max_keys=self.MAX_KEYS, prefix="ds-")++ def delete_key(self, context: RequestContext, dataset_id: str, key_id: str) -> None:+ self._check_access(context, dataset_id)+ key = self._keys.delete_key(context.active_workspace_id, dataset_id, key_id)+ self._cache.delete(key.token, key.type)++ def _check_access(self, context: RequestContext, dataset_id: str) -> None:+ # Enterprise RBAC is enforced at admission; community deployments use the dataset ACL.+ if not self._rbac_enabled():+ access = self._keys.get_dataset_access(context.active_workspace_id, dataset_id, context.account_id)+ if not access.allows(context.account_id):+ raise NoPermissionError("You do not have permission to access this dataset.")++ def list_workspace_keys(self, context: RequestContext) -> tuple[ApiKeyRecord, ...]:+ return self._keys.list_workspace_keys(context.active_workspace_id)++ def create_workspace_key(self, context: RequestContext, dataset_ids: tuple[str, ...]) -> ApiKeyRecord:+ return self._keys.create_workspace_key(+ context.active_workspace_id, tuple(dict.fromkeys(dataset_ids)), max_keys=self.MAX_KEYS, prefix="dataset-"+ )++ def delete_workspace_key(self, context: RequestContext, key_id: str) -> None:+ key = self._keys.delete_workspace_key(context.active_workspace_id, key_id)+ self._cache.delete(key.token, key.type)diff --git a/api/services/knowledge/dataset_access.py b/api/services/knowledge/dataset_access.pynew file mode 100644index 00000000000..c79f40ac513--- /dev/null+++ b/api/services/knowledge/dataset_access.py@@ -0,0 +1,22 @@+"""Dataset ACL policy independent of persistence and request globals."""++from dataclasses import dataclass+++@dataclass(frozen=True, slots=True)+class DatasetAccess:+ permission: str+ maintainer_id: str | None+ role: str | None+ has_explicit_permission: bool++ def allows(self, account_id: str) -> bool:+ if self.role is None:+ return False+ if self.role == "owner" or self.maintainer_id == account_id:+ return True+ if self.permission == "only_me":+ return False+ if self.permission == "partial_members":+ return self.has_explicit_permission+ return self.permission == "all_team_members"diff --git a/api/tests/test_containers_integration_tests/controllers/console/test_apikey.py b/api/tests/test_containers_integration_tests/controllers/console/test_apikey.pyindex e4d378d5260..791c9c7a340 100644--- a/api/tests/test_containers_integration_tests/controllers/console/test_apikey.py+++ b/api/tests/test_containers_integration_tests/controllers/console/test_apikey.py@@ -2,20 +2,22 @@from __future__ import annotations-from unittest.mock import MagicMock, patch+from collections.abc import Iterator+from concurrent.futures import ThreadPoolExecutor, TimeoutError+from threading import Eventfrom uuid import uuid4import pytest-from flask import Flaskfrom flask.testing import FlaskClientfrom sqlalchemy import delete, select-from sqlalchemy.orm import Session+from sqlalchemy.orm import Session, sessionmaker-from models import Account-from models.account import AccountStatus, TenantAccountRole+from models.account import TenantAccountJoin, TenantAccountRolefrom models.dataset import Datasetfrom models.enums import ApiTokenType, DataSourceTypefrom models.model import ApiToken, App, AppMode, DatasetApiTokenBinding+from repositories.knowledge.dataset_api_key_repository import DatasetApiKeyRepository+from services.auth.api_key_contracts import ApiKeyLimitExceededErrorfrom tests.test_containers_integration_tests.controllers.console.helpers import (authenticate_console_client,create_console_account_and_tenant,@@ -58,7 +60,7 @@ def setup_dataset(@pytest.fixture(autouse=True)-def cleanup_api_tokens(db_session_with_containers: Session):+def cleanup_api_tokens(db_session_with_containers: Session) -> Iterator[None]:"""Remove API tokens created during each test."""yielddb_session_with_containers.execute(delete(ApiToken))@@ -186,28 +188,25 @@ class TestAppApiKeyResource:def test_delete_forbidden_for_non_admin(self,- flask_app_with_containers: Flask,+ db_session_with_containers: Session,+ test_client_with_containers: FlaskClient,) -> None:- """A non-admin member cannot delete API keys via the controller permission check."""- from werkzeug.exceptions import Forbidden-- from controllers.console.apikey import BaseApiKeyResource-- resource = BaseApiKeyResource()- resource.resource_type = ApiTokenType.APP- resource.resource_model = MagicMock()- resource.resource_id_field = "app_id"+ """A non-admin member cannot delete API keys through Console admission."""+ account, tenant = create_console_account_and_tenant(db_session_with_containers)+ app = create_console_app(db_session_with_containers, tenant.id, account.id, AppMode.CHAT)+ membership = db_session_with_containers.scalar(+ select(TenantAccountJoin).where(+ TenantAccountJoin.tenant_id == tenant.id, TenantAccountJoin.account_id == account.id+ )+ )+ assert membership is not None+ membership.role = TenantAccountRole.NORMAL+ db_session_with_containers.commit()+ headers = authenticate_console_client(test_client_with_containers, account)- non_admin = Account(name="Normal User", email="[email protected]", status=AccountStatus.ACTIVE)- non_admin.id = "normal-user"- non_admin.role = TenantAccountRole.NORMAL+ response = test_client_with_containers.delete(f"/console/api/apps/{app.id}/api-keys/{uuid4()}", headers=headers)- with (- flask_app_with_containers.test_request_context("/"),- patch("controllers.console.apikey._get_resource"),- ):- with pytest.raises(Forbidden):- BaseApiKeyResource.delete(resource, "rid", "kid", "tenant-id", non_admin)+ assert response.status_code == 403class TestDatasetApiKeyListResource:@@ -311,6 +310,49 @@ class TestDatasetApiKeyListResource:assert listed[scoped_resp.json["id"]] != scoped_resp.json["token"]+def test_dataset_creation_routes_serialize_on_the_same_workspace(+ setup_dataset: tuple[FlaskClient, dict[str, str], Dataset],+ db_session_with_containers: Session,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """The workspace request must wait until the per-dataset count/insert commits."""+ _, _, dataset = setup_dataset+ workspace_id, dataset_id = dataset.tenant_id, dataset.id+ db_session_with_containers.add_all(+ ApiToken(tenant_id=workspace_id, type=ApiTokenType.DATASET, token=f"dataset-{uuid4()}") for _ in range(9)+ )+ db_session_with_containers.commit()+ repository = DatasetApiKeyRepository(session_factory=sessionmaker(bind=db_session_with_containers.get_bind()))+ first_counted, release_first, second_started = Event(), Event(), Event()+ generate_key = ApiToken.generate_api_key++ def pause_first_insert(prefix: str, n: int, *, session: Session) -> str:+ if prefix == "ds-":+ first_counted.set()+ assert release_first.wait(timeout=10), "Timed out waiting to release the first insertion"+ return generate_key(prefix, n, session=session)++ def create_workspace_key() -> None:+ second_started.set()+ repository.create_workspace_key(workspace_id, (), max_keys=10, prefix="dataset-")++ monkeypatch.setattr(ApiToken, "generate_api_key", pause_first_insert)+ with ThreadPoolExecutor(max_workers=2) as pool:+ first = pool.submit(repository.create_key, workspace_id, dataset_id, max_keys=10, prefix="ds-")+ try:+ assert first_counted.wait(timeout=5)+ second = pool.submit(create_workspace_key)+ assert second_started.wait(timeout=5)+ with pytest.raises(TimeoutError):+ second.result(timeout=0.5)+ finally:+ release_first.set()+ first.result(timeout=5)+ with pytest.raises(ApiKeyLimitExceededError):+ second.result(timeout=5)+ assert len(repository.list_workspace_keys(workspace_id)) == 10++class TestDatasetApiKeyResource:"""Tests for DELETE /datasets/api-keys/<api_key_id>."""diff --git a/api/tests/test_containers_integration_tests/services/test_dataset_service_document.py b/api/tests/test_containers_integration_tests/services/test_dataset_service_document.pyindex bf53483f8b3..da7b0416a3d 100644--- a/api/tests/test_containers_integration_tests/services/test_dataset_service_document.py+++ b/api/tests/test_containers_integration_tests/services/test_dataset_service_document.py@@ -12,6 +12,7 @@ from werkzeug.exceptions import Forbidden, NotFoundfrom core.rag.index_processor.constant.index_type import IndexStructureTypefrom extensions.storage.storage_type import StorageTypefrom models import Account+from models.account import TenantAccountRolefrom models.dataset import Dataset, Documentfrom models.enums import CreatorUserRole, DataSourceType, DocumentCreatedFrom, IndexingStatusfrom models.model import UploadFile@@ -119,7 +120,7 @@ def current_user_mock():with patch("services.dataset_service.current_user", create_autospec(Account, instance=True)) as current_user:current_user.id = str(uuid4())current_user.current_tenant_id = str(uuid4())- current_user.current_role = None+ current_user.current_role = TenantAccountRole.EDITORyield current_userdiff --git a/api/tests/unit_tests/controllers/console/agent/test_agent_controllers.py b/api/tests/unit_tests/controllers/console/agent/test_agent_controllers.pyindex 940a06eebeb..78b84398d4f 100644--- a/api/tests/unit_tests/controllers/console/agent/test_agent_controllers.py+++ b/api/tests/unit_tests/controllers/console/agent/test_agent_controllers.py@@ -2,7 +2,7 @@ from datetime import datetimefrom inspect import getsource, unwrapfrom types import SimpleNamespacefrom typing import Any, cast-from unittest.mock import MagicMock, Mock, call+from unittest.mock import MagicMock, Mockimport pytestfrom flask import Flask@@ -24,8 +24,6 @@ from controllers.console.agent.composer import ()from controllers.console.agent.roster import (AgentApiAccessApi,- AgentApiKeyApi,- AgentApiKeyListApi,AgentApiStatusApi,AgentApiStatusPayload,AgentAppApi,@@ -953,11 +951,10 @@ def test_agent_api_key_count_scopes_tenant_and_keeps_legacy_tokens(sqlite_sessioassert roster_controller._agent_api_key_count(sqlite_session, app_model) == 2-def test_agent_api_status_and_key_routes_resolve_backing_app(+def test_agent_api_status_resolves_backing_app(app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session) -> None:agent_id = "00000000-0000-0000-0000-000000000001"- api_key_id = "00000000-0000-0000-0000-000000000002"app_model = _app_detail_obj(id="app-1",tenant_id="tenant-1",@@ -979,34 +976,6 @@ def test_agent_api_status_and_key_routes_resolve_backing_app(monkeypatch.setattr(roster_controller, "AppService", FakeAppService)- def fake_get_api_key_list(self, resource_id: str, tenant_id: str, *, session: object):- captured["list_keys"] = {"session": session, "resource_id": resource_id, "tenant_id": tenant_id}- return roster_controller.ApiKeyList(data=[])-- def fake_create_api_key(self, resource_id: str, tenant_id: str, *, session: object):- captured["create_key"] = {"session": session, "resource_id": resource_id, "tenant_id": tenant_id}- return ApiToken(id=api_key_id, type="app", token="app-test-token", last_used_at=None, created_at=None)-- def fake_delete_api_key(- self,- resource_id: str,- key_id: str,- tenant_id: str,- current_user: object,- *,- session: object,- ) -> None:- captured["delete_key"] = {- "session": session,- "resource_id": resource_id,- "api_key_id": key_id,- "tenant_id": tenant_id,- "current_user": current_user,- }-- monkeypatch.setattr(AgentApiKeyListApi, "_get_api_key_list", fake_get_api_key_list)- monkeypatch.setattr(AgentApiKeyListApi, "_create_api_key", fake_create_api_key)- monkeypatch.setattr(AgentApiKeyApi, "_delete_api_key", fake_delete_api_key)with app.test_request_context("/console/api/agent/00000000-0000-0000-0000-000000000001/api-enable", json={"enable_api": True}):@@ -1015,40 +984,7 @@ def test_agent_api_status_and_key_routes_resolve_backing_app()assert enabled["enabled"] is Trueassert captured["enable"] == {"app": app_model, "enable_api": True}- keys = unwrap(AgentApiKeyListApi.get)(AgentApiKeyListApi(), unbound_session, "tenant-1", agent_id)- assert keys == {"data": []}- assert captured["list_keys"] == {- "session": unbound_session,- "resource_id": "app-1",- "tenant_id": "tenant-1",- }- created, status = unwrap(AgentApiKeyListApi.post)(AgentApiKeyListApi(), unbound_session, "tenant-1", agent_id)- assert status == 201- assert created["id"] == api_key_id- assert created["token"] == "app-test-token"- assert captured["create_key"] == {- "session": unbound_session,- "resource_id": "app-1",- "tenant_id": "tenant-1",- }- current_user = _account(privileged=True)- deleted, delete_status = unwrap(AgentApiKeyApi.delete)(- AgentApiKeyApi(), unbound_session, "tenant-1", current_user, agent_id, api_key_id- )- assert (deleted, delete_status) == ("", 204)- assert captured["delete_key"] == {- "session": unbound_session,- "resource_id": "app-1",- "api_key_id": api_key_id,- "tenant_id": "tenant-1",- "current_user": current_user,- }- assert resolve_app.call_args_list == [- call(unbound_session, tenant_id="tenant-1", agent_id=agent_id),- call(unbound_session, tenant_id="tenant-1", agent_id=agent_id),- call(unbound_session, tenant_id="tenant-1", agent_id=agent_id),- call(unbound_session, tenant_id="tenant-1", agent_id=agent_id),- ]+ resolve_app.assert_called_once_with(unbound_session, tenant_id="tenant-1", agent_id=agent_id)def test_agent_app_update_allows_empty_role(diff --git a/api/tests/unit_tests/controllers/console/datasets/test_datasets.py b/api/tests/unit_tests/controllers/console/datasets/test_datasets.pyindex 277572fa2d4..794c8341add 100644--- a/api/tests/unit_tests/controllers/console/datasets/test_datasets.py+++ b/api/tests/unit_tests/controllers/console/datasets/test_datasets.py@@ -8,14 +8,15 @@ from unittest.mock import ANY, MagicMock, PropertyMock, call, patchimport pytestfrom flask import Flask-from sqlalchemy import event-from sqlalchemy.orm import Session+from sqlalchemy import event, select+from sqlalchemy.orm import Session, sessionmakerfrom werkzeug.exceptions import BadRequest, Forbidden, NotFoundimport servicesfrom controllers.common.rbac import DatasetId, Workspacefrom controllers.console import console_nsfrom controllers.console.app.error import ProviderNotInitializeError+from controllers.console.datasets import datasets as datasets_controllerfrom controllers.console.datasets.datasets import (DatasetApi,DatasetApiBaseUrlApi,@@ -46,12 +47,14 @@ from core.provider_manager import ProviderManagerfrom core.rag.datasource.vdb.vector_type import VectorTypefrom core.rag.index_processor.constant.index_type import IndexStructureTypefrom core.rag.retrieval.retrieval_methods import RetrievalMethod+from extensions.application_services.knowledge import build_dataset_api_key_servicefrom extensions.storage.storage_type import StorageTypefrom fields.dataset_fields import build_dataset_detail_prefetch-from models.account import Account, TenantAccountRole+from machinery.context import RequestContext+from models.account import Account, Tenant, TenantAccountRolefrom models.dataset import AppDatasetJoin, Dataset, DatasetPermission, DatasetQuery, Document, DocumentSegmentfrom models.enums import CreatorUserRole, DataSourceType, DocumentCreatedFrom, IndexingStatus, SegmentStatus-from models.model import ApiToken, App, AppMode, IconType, UploadFile+from models.model import ApiToken, App, AppMode, DatasetApiTokenBinding, IconType, UploadFilefrom services.dataset_ref_service import DatasetReffrom services.dataset_service import DatasetPermissionService, DatasetServicefrom services.enterprise import rbac_service as enterprise_rbac_service@@ -1528,168 +1531,112 @@ class TestDatasetIndexingStatusApi(_UsesSQLiteSession):class TestDatasetApiKeyApi(_UsesSQLiteSession):+ context = RequestContext("request", None, "actor", "tenant-1")++ @pytest.fixture(autouse=True)+ def key_services(self, sqlite_session: Session, sqlite_session_factory: sessionmaker[Session], monkeypatch):+ tenant = Tenant(name="Workspace")+ tenant.id = "tenant-1"+ sqlite_session.add(tenant)+ sqlite_session.commit()+ service = build_dataset_api_key_service(database_client=sqlite_session_factory)+ monkeypatch.setattr(+ datasets_controller,+ "application_services",+ lambda: SimpleNamespace(dataset_api_keys=service),+ )+def test_get_api_keys_success(self, app: Flask):api = DatasetApiKeyApi()- method = unwrap(api.get)- mock_key_1 = ApiToken(- id="key-1",- type="dataset",- token="dataset-aaaa1111bbbb",- last_used_at=None,- created_at=None,- )- mock_key_2 = ApiToken(- id="key-2",- type="dataset",- token="dataset-cccc2222dddd",- last_used_at=None,- created_at=None,+ self.session.add_all(+ [+ ApiToken(id="key-1", tenant_id="tenant-1", type="dataset", token="dataset-aaaa1111bbbb"),+ ApiToken(id="key-2", tenant_id="tenant-1", type="dataset", token="dataset-cccc2222dddd"),+ ])- session = self.session- mock_key_1.tenant_id = "tenant-1"- mock_key_2.tenant_id = "tenant-1"- session.add_all([mock_key_1, mock_key_2])- session.flush()+ self.session.commit()with app.test_request_context("/"):- response = method(api, session, "tenant-1")- assert "data" in response- assert len(response["data"]) == 2- # reveal-once: the list returns masked tokens, never the full secret- assert response["data"][0]["id"] == "key-1"- assert response["data"][0]["token"] == "datas...bbbb"- assert response["data"][1]["id"] == "key-2"- assert response["data"][1]["token"] == "datas...dddd"+ response = unwrap(api.get)(api, self.context)+ assert [key["token"] for key in response["data"]] == ["datas...bbbb", "datas...dddd"]def test_post_create_api_key_success(self, app: Flask):api = DatasetApiKeyApi()- method = unwrap(api.post)- session = self.session- with (- app.test_request_context("/"),- patch.object(ApiToken, "generate_api_key", return_value="dataset-abc123") as generate_api_key,- ):- response, status = method(api, session, "tenant-1")+ with app.test_request_context("/"):+ response, status = unwrap(api.post)(api, self.context)assert status == 200- assert isinstance(response, dict)- assert response["token"] == "dataset-abc123"+ assert response["token"].startswith("dataset-")assert response["type"] == "dataset"+ assert response["dataset_ids"] == []assert response["created_at"] is not None- generate_api_key.assert_called_once_with("dataset-", 24, session=session)- assert session.get(ApiToken, response["id"]).token == "dataset-abc123"+ stored = self.session.get(ApiToken, response["id"])+ assert stored is not None+ assert stored.token == response["token"]def test_post_exceed_max_keys(self, app: Flask):api = DatasetApiKeyApi()- method = unwrap(api.post)- session = self.session- session.add_all(- [- ApiToken(id=f"key-{index}", tenant_id="tenant-1", type="dataset", token=f"ds-{index}")- for index in range(10)- ]+ self.session.add_all(+ [ApiToken(id=f"key-{i}", tenant_id="tenant-1", type="dataset", token=f"ds-{i}") for i in range(10)])- session.flush()- with app.test_request_context("/"):- with pytest.raises(BadRequest) as exc_info:- method(api, session, "tenant-1")- assert exc_info.value.code == 400+ self.session.commit()+ with app.test_request_context("/"), pytest.raises(BadRequest) as exc_info:+ unwrap(api.post)(api, self.context)assert vars(exc_info.value)["data"] == {"message": "Cannot create more than 10 API keys for this resource type.","custom": "max_keys_exceeded",}- def test_get_api_keys_include_bound_dataset_ids(self, app: Flask):+ def test_scoped_key_persists_bindings_and_lists_masked_scope(self, app: Flask):api = DatasetApiKeyApi()- method = unwrap(api.get)- mock_key = MagicMock(spec=ApiToken)- mock_key.id = "key-1"- mock_key.type = "dataset"- mock_key.token = "dataset-aaaa1111bbbb"- mock_key.last_used_at = None- mock_key.created_at = None- session = MagicMock()- session.scalars.return_value.all.return_value = [mock_key]- # Two binding rows for the same key -> the masked list surfaces both dataset ids.- session.execute.return_value.all.return_value = [("key-1", "ds-1"), ("key-1", "ds-2")]- with app.test_request_context("/"):- response = method(api, session, "tenant-1")- assert response["data"][0]["dataset_ids"] == ["ds-1", "ds-2"]-- def test_post_create_scoped_key_persists_bindings(self, app: Flask):- api = DatasetApiKeyApi()- method = unwrap(api.post)- mock_token = MagicMock()- mock_token.id = "new-key-id"- mock_token.last_used_at = None- mock_token.created_at = datetime.datetime(2024, 1, 1, 0, 0, 0, tzinfo=datetime.UTC)- mock_api_token_cls = MagicMock()- mock_api_token_cls.return_value = mock_token- mock_api_token_cls.generate_api_key.return_value = "dataset-abc123"- session = MagicMock()- # Dataset-ownership validation returns exactly the requested ids (all belong to tenant).- session.scalars.return_value.all.return_value = ["ds-1", "ds-2"]- session.scalar.return_value = 1- with (- app.test_request_context("/", json={"dataset_ids": ["ds-1", "ds-2", "ds-1"]}),- patch("controllers.console.datasets.datasets.ApiToken", mock_api_token_cls),- ):- response, status = method(api, session, "tenant-1")+ self.session.add_all(+ [+ make_dataset(id="ds-1", tenant_id="tenant-1"),+ make_dataset(id="ds-2", tenant_id="tenant-1"),+ ]+ )+ self.session.commit()+ with app.test_request_context("/", json={"dataset_ids": ["ds-1", "ds-2", "ds-1"]}):+ response, status = unwrap(api.post)(api, self.context)+ listed = unwrap(api.get)(api, self.context)assert status == 200- # Duplicates are collapsed and returned in the reveal-once response.assert response["dataset_ids"] == ["ds-1", "ds-2"]- # One binding row is added per unique dataset id (plus the token itself).- added = [call.args[0] for call in session.add.call_args_list]- binding_dataset_ids = [obj.dataset_id for obj in added if obj.__class__.__name__ == "DatasetApiTokenBinding"]- assert binding_dataset_ids == ["ds-1", "ds-2"]+ bindings = self.session.scalars(+ select(DatasetApiTokenBinding).where(DatasetApiTokenBinding.api_token_id == response["id"])+ ).all()+ assert {binding.dataset_id for binding in bindings} == {"ds-1", "ds-2"}+ assert set(listed["data"][0]["dataset_ids"]) == {"ds-1", "ds-2"}+ assert listed["data"][0]["token"] != response["token"]def test_post_rejects_dataset_ids_from_another_tenant(self, app: Flask):api = DatasetApiKeyApi()- method = unwrap(api.post)- session = MagicMock()- # None of the requested ids belong to this tenant.- session.scalars.return_value.all.return_value = []- with app.test_request_context("/", json={"dataset_ids": ["foreign-ds"]}):- with pytest.raises(BadRequest) as exc_info:- method(api, session, "tenant-1")- assert exc_info.value.code == 400+ self.session.add(make_dataset(id="foreign-ds", tenant_id="foreign"))+ self.session.commit()+ with app.test_request_context("/", json={"dataset_ids": ["foreign-ds"]}), pytest.raises(BadRequest) as exc_info:+ unwrap(api.post)(api, self.context)assert "Unknown knowledge base id(s)" in vars(exc_info.value)["data"]["message"]+ assert self.session.scalar(select(ApiToken)) is None- def test_post_rejects_non_list_dataset_ids(self, app: Flask):+ @pytest.mark.parametrize("dataset_ids", ["not-a-list", [1]])+ def test_post_rejects_invalid_dataset_ids(self, app: Flask, dataset_ids):api = DatasetApiKeyApi()- method = unwrap(api.post)- session = MagicMock()- with app.test_request_context("/", json={"dataset_ids": "not-a-list"}):- with pytest.raises(BadRequest) as exc_info:- method(api, session, "tenant-1")- assert exc_info.value.code == 400+ with app.test_request_context("/", json={"dataset_ids": dataset_ids}), pytest.raises(BadRequest) as exc_info:+ unwrap(api.post)(api, self.context)assert vars(exc_info.value)["data"]["message"] == "dataset_ids must be a list of strings."--class TestDatasetApiDeleteApi(_UsesSQLiteSession):def test_delete_success(self, app: Flask):api = DatasetApiDeleteApi()- method = unwrap(api.delete)- session = self.session- key = ApiToken(id="api-key-id", tenant_id="tenant-1", type="dataset", token="dataset-secret")- session.add(key)- session.flush()- with (- app.test_request_context("/"),- patch("controllers.console.datasets.datasets.ApiTokenCache.delete") as delete_cache,- ):- response, status = method(api, session, "tenant-1", "api-key-id")- assert status == 204- assert response == ""- delete_cache.assert_called_once()- session.flush()- assert session.get(ApiToken, "api-key-id") is None+ self.session.add(ApiToken(id="api-key-id", tenant_id="tenant-1", type="dataset", token="dataset-secret"))+ self.session.commit()+ with app.test_request_context("/"), patch("services.api_token_service.ApiTokenCache.delete") as invalidate:+ result = unwrap(api.delete)(api, self.context, "api-key-id")+ assert result == ("", 204)+ self.session.expire_all()+ assert self.session.get(ApiToken, "api-key-id") is None+ invalidate.assert_called_once_with("dataset-secret", "dataset")def test_delete_key_not_found(self, app: Flask):api = DatasetApiDeleteApi()- method = unwrap(api.delete)- session = self.session- with app.test_request_context("/"):- with pytest.raises(NotFound):- method(api, session, "tenant-1", "api-key-id")+ with app.test_request_context("/"), pytest.raises(NotFound):+ unwrap(api.delete)(api, self.context, "api-key-id")class TestDatasetEnableApiApi(_UsesSQLiteSession):diff --git a/api/tests/unit_tests/controllers/console/test_apikey.py b/api/tests/unit_tests/controllers/console/test_apikey.pyindex d6ae0d4bd7f..882bd9bdaeb 100644--- a/api/tests/unit_tests/controllers/console/test_apikey.py+++ b/api/tests/unit_tests/controllers/console/test_apikey.py@@ -1,338 +1,317 @@-from __future__ import annotations+"""API key admission, delegation, error and response contracts."""-import inspectfrom collections.abc import Callable+from dataclasses import dataclass, field+from datetime import UTC, datetimefrom typing import cast-from unittest.mock import MagicMock, patch+from unittest.mock import Mockfrom uuid import UUIDimport pytestfrom flask import Flask-from sqlalchemy import event, select-from sqlalchemy.orm import Session-from werkzeug.exceptions import BadRequest, Forbidden, NotFound--from controllers.console.agent.roster import AgentApiKeyListApi-from controllers.console.apikey import (- AppApiKeyListResource,- BaseApiKeyListResource,- BaseApiKeyResource,- DatasetApiKeyListResource,-)-from controllers.console.datasets.datasets import DatasetApiKeyApi-from core.rbac import RBACPermission, RBACResourceScope+from flask_restx import Api+from sqlalchemy import select+from sqlalchemy.orm import Session, sessionmaker++from controllers.console import apikey, flask_admission, wraps+from controllers.console.agent import roster+from controllers.console.datasets import datasets+from core.rbac import RBACPermissionfrom enums import DeploymentEdition-from models import Account-from models.account import AccountStatus, TenantAccountRole-from models.enums import ApiTokenType-from models.model import ApiToken, App, AppMode, IconType-from services.agent.errors import AgentAccessNotReadyError---def _make_list_resource() -> BaseApiKeyListResource:- resource = BaseApiKeyListResource()- resource.resource_type = ApiTokenType.APP- resource.resource_model = App- resource.resource_id_field = "app_id"- resource.token_prefix = "app-"- return resource---def _make_key_resource() -> BaseApiKeyResource:- resource = BaseApiKeyResource()- resource.resource_type = ApiTokenType.APP- resource.resource_model = App- resource.resource_id_field = "app_id"- return resource---def _make_account(role: TenantAccountRole) -> Account:- account = Account(- name="Test User",- email=f"{role.value}@example.com",- status=AccountStatus.ACTIVE,- )- account.id = f"{role.value}-user"- account.role = role- return account---def _persist_app(session: Session, *, mode: AppMode = AppMode.CHAT, app_id: str = "app-1") -> App:- app = App(- id=app_id,- tenant_id="tenant-1",- name="API key app",- mode=mode,- icon_type=IconType.EMOJI,- icon="chat",- icon_background="#ffffff",- enable_site=False,- enable_api=True,- )- session.add(app)- session.flush()- return app-+from extensions.application_services.knowledge import build_dataset_api_key_service+from extensions.ext_application_services import ApplicationServices+from libs.login import AccountWithTenant+from machinery.context import RequestContext+from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole+from models.dataset import Dataset+from models.model import ApiToken+from services.app.api_key_service import AppApiKeyNotReadyError+from services.auth.api_key_contracts import (+ ApiKeyLimitExceededError,+ ApiKeyNotFoundError,+ ApiKeyRecord,+ ApiKeyResourceNotFoundError,+)-def test_list_api_keys_uses_injected_session_and_tenant_id(sqlite_session: Session) -> None:- resource = _make_list_resource()- raw_get = cast(- Callable[[BaseApiKeyListResource, object, str, str], dict[str, object]],- inspect.unwrap(BaseApiKeyListResource.get),- )- session = sqlite_session- _persist_app(session)- api_key = ApiToken(- type=ApiTokenType.APP,- token="app-token",- app_id="app-1",- tenant_id="tenant-1",- )- api_key.id = "key-1"- session.add(api_key)- session.add(- ApiToken(- type=ApiTokenType.APP,- token="foreign-app-token",- app_id="app-1",- tenant_id="tenant-2",+RESOURCE_ID = UUID("00000000-0000-0000-0000-000000000001")+KEY_ID = UUID("00000000-0000-0000-0000-000000000002")+++@dataclass+class RecordingKeys:+ calls: list[tuple[str, RequestContext, str, str, str | None]] = field(default_factory=list)+ error: Exception | None = None++ def _record(+ self,+ operation: str,+ context: RequestContext,+ kind: str,+ resource_id: str,+ key_id: str | None = None,+ ) -> ApiKeyRecord:+ self.calls.append((operation, context, kind, resource_id, key_id))+ if self.error:+ raise self.error+ return ApiKeyRecord(+ id=str(KEY_ID),+ type="dataset" if kind == "dataset" else "app",+ token="app-secret-token",+ created_at=datetime(2026, 1, 1, tzinfo=UTC),+ dataset_ids=(resource_id,) if kind == "dataset" else (),)- )- legacy_api_key = ApiToken(type=ApiTokenType.APP, token="legacy-app-token", app_id="app-1", tenant_id=None)- session.add(legacy_api_key)- session.commit()- result = raw_get(resource, session, "app-1", "tenant-1")- data = cast(list[dict[str, object]], result["data"])+ def list_keys(self, context: RequestContext, app_id: str) -> tuple[ApiKeyRecord, ...]:+ return (self._record("list", context, "app", app_id),)- assert {item["token"] for item in data} == {"app-token", "legacy-app-token"}+ def create_key(self, context: RequestContext, app_id: str) -> ApiKeyRecord:+ return self._record("create", context, "app", app_id)+ def delete_key(self, context: RequestContext, app_id: str, key_id: str) -> None:+ self._record("delete", context, "app", app_id, key_id)-def test_create_api_key_uses_injected_session_and_tenant_id(sqlite_session: Session) -> None:- resource = _make_list_resource()- raw_post = cast(- Callable[[BaseApiKeyListResource, object, str, str], tuple[dict[str, object], int]],- inspect.unwrap(BaseApiKeyListResource.post),- )- session = sqlite_session- _persist_app(session)- session.add_all(- [- ApiToken(type=ApiTokenType.APP, token=f"foreign-token-{index}", app_id="app-1", tenant_id="tenant-2")- for index in range(resource.max_keys)- ]- )- session.commit()- commits: list[str] = []- event.listen(session, "after_commit", lambda _session: commits.append("commit"))-- with patch(- "controllers.console.apikey.ApiToken.generate_api_key", return_value="app-generated-token"- ) as generate_api_key:- result, status = raw_post(resource, session, "app-1", "tenant-1")-- assert status == 201- assert result["token"] == "app-generated-token"- api_token = session.scalar(select(ApiToken).where(ApiToken.token == "app-generated-token"))- assert api_token is not None- assert api_token.app_id == "app-1"- assert api_token.tenant_id == "tenant-1"- assert api_token.type == ApiTokenType.APP- generate_api_key.assert_called_once_with("app-", 24, session=session)- assert commits == ["commit"]---def test_create_api_key_counts_legacy_tokens(sqlite_session: Session) -> None:- resource = _make_list_resource()- _persist_app(sqlite_session)- sqlite_session.add_all(- [- ApiToken(type=ApiTokenType.APP, token=f"legacy-token-{index}", app_id="app-1", tenant_id=None)- for index in range(resource.max_keys)- ]- )- sqlite_session.commit()+ def list_agent_keys(self, context: RequestContext, agent_id: str) -> tuple[ApiKeyRecord, ...]:+ return (self._record("list", context, "agent", agent_id),)- with pytest.raises(BadRequest):- resource._create_api_key("app-1", "tenant-1", session=sqlite_session)+ def create_agent_key(self, context: RequestContext, agent_id: str) -> ApiKeyRecord:+ return self._record("create", context, "agent", agent_id)+ def delete_agent_key(self, context: RequestContext, agent_id: str, key_id: str) -> None:+ self._record("delete", context, "agent", agent_id, key_id)-def test_create_agent_api_key_requires_published_access(sqlite_session: Session) -> None:- resource = _make_list_resource()- session = sqlite_session- app = _persist_app(session, mode=AppMode.AGENT)- with patch(- "controllers.console.apikey.AppService.ensure_agent_app_access_ready",- side_effect=AgentAccessNotReadyError(),- ) as ensure_access_ready:- with pytest.raises(AgentAccessNotReadyError):- resource._create_api_key("app-1", "tenant-1", session=session)+@dataclass+class RecordingDatasetKeys:+ recorder: RecordingKeys- ensure_access_ready.assert_called_once_with(app, session=session)- assert session.scalar(select(ApiToken)) is None+ def list_keys(self, context: RequestContext, dataset_id: str) -> tuple[ApiKeyRecord, ...]:+ return (self.recorder._record("list", context, "dataset", dataset_id),)+ def create_key(self, context: RequestContext, dataset_id: str) -> ApiKeyRecord:+ return self.recorder._record("create", context, "dataset", dataset_id)-def test_delete_api_key_rejects_non_admin_account(sqlite_session: Session) -> None:- resource = _make_key_resource()- raw_delete = cast(- Callable[[BaseApiKeyResource, object, str, str, str, Account], tuple[str, int]],- inspect.unwrap(BaseApiKeyResource.delete),- )- session = sqlite_session- _persist_app(session)-- with pytest.raises(Forbidden):- raw_delete(- resource,- session,- "app-1",- "key-1",- "tenant-1",- _make_account(TenantAccountRole.NORMAL),- )+ def delete_key(self, context: RequestContext, dataset_id: str, key_id: str) -> None:+ self.recorder._record("delete", context, "dataset", dataset_id, key_id)+ def list_workspace_keys(self, context: RequestContext) -> tuple[ApiKeyRecord, ...]:+ return (self.recorder._record("list", context, "dataset", "workspace"),)-def test_delete_api_key_uses_injected_session_user_and_tenant(sqlite_session: Session) -> None:- resource = _make_key_resource()- raw_delete = cast(- Callable[[BaseApiKeyResource, object, str, str, str, Account], tuple[str, int]],- inspect.unwrap(BaseApiKeyResource.delete),- )- session = sqlite_session- _persist_app(session)- api_key = ApiToken(type=ApiTokenType.APP, token="app-token", app_id="app-1", tenant_id=None)- api_key.id = "key-1"- session.add(api_key)- session.commit()- commits: list[str] = []- event.listen(session, "after_commit", lambda _session: commits.append("commit"))-- with patch("controllers.console.apikey.ApiTokenCache.delete") as delete_cache:- result, status = raw_delete(- resource,- session,- "app-1",- "key-1",- "tenant-1",- _make_account(TenantAccountRole.OWNER),- )+ def create_workspace_key(self, context: RequestContext, _dataset_ids: tuple[str, ...]) -> ApiKeyRecord:+ return self.recorder._record("create", context, "dataset", "workspace")- delete_cache.assert_called_once_with("app-token", ApiTokenType.APP)- assert session.get(ApiToken, "key-1") is None- assert commits == ["commit"]- assert result == ""- assert status == 204---def test_delete_api_key_rejects_foreign_tenant_token(sqlite_session: Session) -> None:- resource = _make_key_resource()- session = sqlite_session- _persist_app(session)- api_key = ApiToken(type=ApiTokenType.APP, token="foreign-token", app_id="app-1", tenant_id="tenant-2")- api_key.id = "key-1"- session.add(api_key)- session.commit()-- with patch("controllers.console.apikey.ApiTokenCache.delete") as delete_cache:- with pytest.raises(NotFound):- resource._delete_api_key(- "app-1",- "key-1",- "tenant-1",- _make_account(TenantAccountRole.OWNER),- session=session,- )-- delete_cache.assert_not_called()- assert session.get(ApiToken, "key-1") is api_key---def test_api_key_lists_require_matching_rbac_permission(config_overrides: Callable[..., None]) -> None:- config_overrides(- DEPLOYMENT_EDITION=DeploymentEdition.CLOUD,- LOGIN_DISABLED=True,- RBAC_ENABLED=True,- )+ def delete_workspace_key(self, context: RequestContext, key_id: str) -> None:+ self.recorder._record("delete", context, "dataset", "workspace", key_id)+++@dataclass+class ApiKeyTestServices:+ app_api_keys: RecordingKeys+ dataset_api_keys: RecordingDatasetKeys+++type KeysApp = tuple[Flask, RecordingKeys, Account]+++def keys_app(monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None]) -> KeysApp:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD, LOGIN_DISABLED=True, RBAC_ENABLED=False)+ account = Account(name="Owner", email="[email protected]", status=AccountStatus.ACTIVE)+ account.id = "actor"+ account.role = TenantAccountRole.OWNER++ def current_account() -> AccountWithTenant:+ return AccountWithTenant(account, "workspace")++ monkeypatch.setattr(flask_admission, "current_account_with_tenant", current_account)+ monkeypatch.setattr(wraps, "current_account_with_tenant", current_account)+ monkeypatch.setattr(flask_admission, "get_request_id", lambda: "request-id")+ monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)+ keys = RecordingKeys()+ services = cast(ApplicationServices, ApiKeyTestServices(keys, RecordingDatasetKeys(keys)))+ monkeypatch.setattr(apikey, "application_services", lambda: services)+ monkeypatch.setattr(roster, "application_services", lambda: services)+ monkeypatch.setattr(datasets, "application_services", lambda: services)app = Flask(__name__)- account = _make_account(TenantAccountRole.OWNER)- api_id = UUID("00000000-0000-0000-0000-000000000001")- cases = [- (- lambda: AppApiKeyListResource().get(resource_id=api_id),- {- "scene": RBACPermission.APP_RELEASE_AND_VERSION,- "resource_type": RBACResourceScope.APP,- "resource_id": str(api_id),- },- ),- (- lambda: DatasetApiKeyApi().get(),- {"scene": RBACPermission.DATASET_API_KEY_MANAGE, "resource_type": None, "resource_id": None},- ),- (- lambda: DatasetApiKeyListResource().get(resource_id=api_id),- {- "scene": RBACPermission.DATASET_API_KEY_MANAGE,- "resource_type": RBACResourceScope.DATASET,- "resource_id": str(api_id),- },- ),+ api = Api(app)+ api.add_resource(apikey.AppApiKeyListResource, "/app/<uuid:resource_id>")+ api.add_resource(apikey.AppApiKeyResource, "/app/<uuid:resource_id>/<uuid:api_key_id>")+ api.add_resource(apikey.DatasetApiKeyListResource, "/dataset/<uuid:resource_id>")+ api.add_resource(apikey.DatasetApiKeyResource, "/dataset/<uuid:resource_id>/<uuid:api_key_id>")+ api.add_resource(roster.AgentApiKeyListApi, "/agent/<uuid:agent_id>")+ api.add_resource(roster.AgentApiKeyApi, "/agent/<uuid:agent_id>/<uuid:api_key_id>")+ api.add_resource(datasets.DatasetApiKeyApi, "/workspace-keys")+ api.add_resource(datasets.DatasetApiDeleteApi, "/workspace-keys/<uuid:api_key_id>")+ return app, keys, account++[email protected]("kind", ["app", "dataset", "agent"])+def test_key_routes_forward_stable_context_and_serialize(keys_app: KeysApp, kind: str) -> None:+ app, keys, _ = keys_app+ client = app.test_client()+ path = f"/{kind}/{RESOURCE_ID}"+ headers = {"X-Trace-Id": "trace-id"}++ listed = client.get(path, headers=headers)+ created = client.post(path, headers=headers)+ deleted = client.delete(f"{path}/{KEY_ID}", headers=headers)++ assert listed.status_code == 200+ assert listed.json is not None+ assert listed.json["data"][0]["token"] == ("app-s...oken" if kind == "dataset" else "app-secret-token")+ assert listed.json["data"][0]["dataset_ids"] == ([str(RESOURCE_ID)] if kind == "dataset" else [])+ assert created.status_code == 201+ assert created.json is not None+ assert created.json["token"] == "app-secret-token"+ assert created.json["created_at"] == 1767225600+ assert deleted.status_code == 204+ assert deleted.data == b""+ context = RequestContext("request-id", "trace-id", "actor", "workspace")+ assert keys.calls == [+ ("list", context, kind, str(RESOURCE_ID), None),+ ("create", context, kind, str(RESOURCE_ID), None),+ ("delete", context, kind, str(RESOURCE_ID), str(KEY_ID)),]- with (- app.test_request_context("/"),- patch("controllers.console.wraps.current_account_with_tenant", return_value=(account, "tenant-1")),- patch("controllers.common.wraps.current_account_with_tenant", return_value=(account, "tenant-1")),- patch("controllers.common.rbac.locators.agent_binding", return_value=None),- patch("controllers.common.rbac.locators.PlainApp.owner_id", return_value=None),- patch("controllers.common.rbac.locators.DatasetId.owner_id", return_value=None),- patch.object(BaseApiKeyListResource, "_get_api_key_list") as get_api_key_list,- ):- for invoke, expected_kwargs in cases:- with patch(- "controllers.common.rbac.checks.RBACService.CheckAccess.check", return_value=False- ) as check_access:- with pytest.raises(Forbidden):- invoke()-- check_access.assert_called_once_with(- "tenant-1",- account.id,- scene=expected_kwargs["scene"],- resource_type=expected_kwargs["resource_type"],- resource_id=expected_kwargs["resource_id"],- )-- get_api_key_list.assert_not_called()---def test_api_key_lists_reject_legacy_read_only_members(config_overrides: Callable[..., None]) -> None:- config_overrides(- DEPLOYMENT_EDITION=DeploymentEdition.CLOUD,- LOGIN_DISABLED=True,- RBAC_ENABLED=False,+[email protected]("kind", ["app", "dataset", "agent"])[email protected]("role", list(TenantAccountRole))[email protected]("method", ["GET", "POST", "DELETE"])+def test_admission_preserves_role_policy(keys_app: KeysApp, kind: str, role: TenantAccountRole, method: str) -> None:+ app, keys, account = keys_app+ account.role = role+ path = f"/{kind}/{RESOURCE_ID}" + (f"/{KEY_ID}" if method == "DELETE" else "")+ response = app.test_client().open(path, method=method)+ allowed = role in (apikey.API_KEY_DELETE_ROLES if method == "DELETE" else apikey.API_KEY_EDIT_ROLES)+ assert response.status_code == ({"GET": 200, "POST": 201, "DELETE": 204}[method] if allowed else 403)+ assert bool(keys.calls) is allowed+++ ("error", "status", "message"),+ [+ (ApiKeyResourceNotFoundError("App not found."), 404, "App not found."),+ (ApiKeyNotFoundError(), 404, "API key not found"),+ (ApiKeyLimitExceededError(10), 400, "Cannot create more than 10 API keys for this resource type."),+ (AppApiKeyNotReadyError(), 409, "Publish the Agent before enabling Web App or API access."),+ ],+)+def test_errors_keep_http_contract(keys_app: KeysApp, error: Exception, status: int, message: str) -> None:+ app, keys, _ = keys_app+ keys.error = error+ response = app.test_client().post(f"/app/{RESOURCE_ID}")+ assert response.status_code == status+ assert response.json is not None+ assert response.json["message"].startswith(message)+ if isinstance(error, ApiKeyLimitExceededError):+ assert response.json["custom"] == "max_keys_exceeded"+++ ("kind", "permission"),+ [+ ("app", RBACPermission.APP_RELEASE_AND_VERSION),+ ("dataset", RBACPermission.DATASET_API_KEY_MANAGE),+ ("agent", RBACPermission.AGENT_ACCESS_POINT_VIEW),+ ],+)[email protected]("allowed", [False, True])+def test_rbac_admission_controls_service_access(+ keys_app: KeysApp,+ config_overrides: Callable[..., None],+ monkeypatch: pytest.MonkeyPatch,+ kind: str,+ permission: RBACPermission,+ allowed: bool,+) -> None:+ from controllers.common.rbac import checks, locators++ app, keys, account = keys_app+ account.role = TenantAccountRole.NORMAL+ config_overrides(RBAC_ENABLED=True)+ monkeypatch.setattr(locators, "agent_binding", lambda *_args, **_kwargs: None)+ monkeypatch.setattr(locators.PlainApp, "owner_id", lambda *_args, **_kwargs: None)+ monkeypatch.setattr(locators.DatasetId, "owner_id", lambda *_args, **_kwargs: None)+ monkeypatch.setattr(locators.AgentId, "owner_id", lambda *_args, **_kwargs: None)+ check = Mock(return_value=allowed)+ monkeypatch.setattr(checks.RBACService.CheckAccess, "check", check)++ response = app.test_client().get(f"/{kind}/{RESOURCE_ID}")++ assert response.status_code == (200 if allowed else 403)+ assert check.call_args.kwargs["scene"] == permission+ assert bool(keys.calls) is allowed+++def test_uninitialized_account_is_rejected(keys_app: KeysApp) -> None:+ app, keys, account = keys_app+ account.status = AccountStatus.UNINITIALIZED+ assert app.test_client().post(f"/app/{RESOURCE_ID}").status_code == 400+ assert keys.calls == []++[email protected]("role", list(TenantAccountRole))[email protected]("method", ["GET", "POST", "DELETE"])+def test_workspace_key_admission_preserves_admin_role_policy(+ keys_app: KeysApp, role: TenantAccountRole, method: str+) -> None:+ app, keys, account = keys_app+ account.role = role+ path = "/workspace-keys" + (f"/{KEY_ID}" if method == "DELETE" else "")+ response = app.test_client().open(path, method=method)+ allowed = role in apikey.API_KEY_DELETE_ROLES+ assert response.status_code == ({"GET": 200, "POST": 200, "DELETE": 204}[method] if allowed else 403)+ assert bool(keys.calls) is allowed+++def persisted_keys_app(+ keys_app: KeysApp,+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+) -> KeysApp:+ app, keys, account = keys_app+ assert account.role is not None+ tenant = Tenant(name="Workspace")+ tenant.id = "workspace"+ sqlite_session.add_all(+ [+ tenant,+ TenantAccountJoin(tenant_id="workspace", account_id=account.id, role=account.role),+ Dataset(id=str(RESOURCE_ID), tenant_id="workspace", name="Private", created_by="other", maintainer="other"),+ ])- app = Flask(__name__)- account = _make_account(TenantAccountRole.NORMAL)- api_id = UUID("00000000-0000-0000-0000-000000000001")- current_user = MagicMock()- current_user._get_current_object.return_value = account- current_user.has_edit_permission = False-- with (- app.test_request_context("/"),- patch("libs.login.current_user", current_user),- patch("controllers.console.wraps.current_account_with_tenant", return_value=(account, "tenant-1")),- patch.object(BaseApiKeyListResource, "_get_api_key_list") as get_api_key_list,- ):- for invoke in (- lambda: AppApiKeyListResource().get(resource_id=api_id),- lambda: AgentApiKeyListApi().get(agent_id=api_id),- lambda: DatasetApiKeyApi().get(),- lambda: DatasetApiKeyListResource().get(resource_id=api_id),- ):- with pytest.raises(Forbidden):- invoke()-- get_api_key_list.assert_not_called()+ sqlite_session.commit()+ service = build_dataset_api_key_service(database_client=sqlite_session_factory)+ services = Mock(dataset_api_keys=service)+ monkeypatch.setattr(apikey, "application_services", lambda: services)+ monkeypatch.setattr(datasets, "application_services", lambda: services)+ return app, keys, account+++def test_private_dataset_rejects_editor_without_creating_token(+ persisted_keys_app: KeysApp, sqlite_session: Session+) -> None:+ app, _, account = persisted_keys_app+ account.role = TenantAccountRole.EDITOR+ member = sqlite_session.scalar(select(TenantAccountJoin))+ assert member is not None+ member.role = account.role+ sqlite_session.commit()+ response = app.test_client().post(f"/dataset/{RESOURCE_ID}")+ assert response.status_code == 403+ assert sqlite_session.scalar(select(ApiToken)) is None+++def test_both_http_routes_enforce_the_same_key_limit(persisted_keys_app: KeysApp, sqlite_session: Session) -> None:+ app, _, _ = persisted_keys_app+ client = app.test_client()+ for _ in range(5):+ assert client.post("/workspace-keys").status_code == 200+ assert client.post(f"/dataset/{RESOURCE_ID}").status_code == 201+ for path in ("/workspace-keys", f"/dataset/{RESOURCE_ID}"):+ response = client.post(path)+ assert response.status_code == 400+ assert response.json is not None+ assert response.json["custom"] == "max_keys_exceeded"+ assert len(sqlite_session.scalars(select(ApiToken)).all()) == 10diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex 6f8d8b9f207..fa23943ef55 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -36,6 +36,7 @@ from repositories.app_site_command_repository import AppSiteCommandRepositoryfrom repositories.app_statistic_query_repository import AppStatisticQueryRepositoryfrom repositories.app_tracing_config_repository import SQLAlchemyAppTracingConfigRepositoryfrom repositories.human_input_file_upload_repository import SQLAlchemyHumanInputFileUploadRepository+from repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom repositories.message_file_preview_repository import MessageFilePreviewQueryRepositoryfrom repositories.plugin_file_upload_repository import SQLAlchemyPluginFileUploadOwnerRepositoryfrom repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository@@ -66,6 +67,7 @@ from services.account_oauth_adapters import (DeploymentOAuthPolicyGateway,RedisOAuthAccountClaimLock,)+from services.app.api_key_service import AppApiKeyServicefrom services.app_generate_service import AppGenerateServicefrom services.app_preview_query_service import AppPreviewRef, AppPreviewUnavailableErrorfrom services.app_scoped_end_user_query_service import AppScopedEndUserQueryService@@ -84,7 +86,11 @@ from services.file_service import FileServicefrom services.human_input_file_upload_service import HumanInputFileUploadServicefrom services.init_validation_service import InvalidInitializationPasswordErrorfrom services.installed_app_access_service import InstalledAppAccessDeniedError, InstalledAppRef+from services.installed_app_generation_adapters import AppGenerateServiceRuntime as InstalledAppGenerateServiceRuntime+from services.installed_app_generation_service import InstalledAppGenerationService+from services.knowledge.api_key_service import DatasetApiKeyServicefrom services.message_file_preview_service import MessageFilePreviewService+from services.oauth_device_application_service import OAuthDeviceApplicationServicefrom services.partner_tenant_binding_service import PartnerTenantBindingServicefrom services.plugin_file_upload_gateway import ToolFilePluginUploadGatewayfrom services.plugin_file_upload_service import PluginFileUploadService@@ -177,6 +183,33 @@ def test_init_app_registers_services_for_the_current_app(assert isinstance(services.workflow_statistics, WorkflowStatisticQueryService)+def test_build_application_services_preserves_composed_boundaries(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ redis = MagicMock(spec=RedisClientWrapper)++ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=redis,+ )++ assert isinstance(services.app_api_keys, AppApiKeyService)+ assert isinstance(services.dataset_api_keys, DatasetApiKeyService)+ assert isinstance(services.oauth_device, OAuthDeviceApplicationService)+ assert redis.register_script.call_count == 3++ assert isinstance(services.installed_app_generation, InstalledAppGenerationService)+ installed_apps = services.installed_app_access._installed_apps+ assert isinstance(installed_apps, SQLAlchemyInstalledAppRepository)+ assert services.installed_app_generation._usage is installed_apps+ assert services.installed_app_generation._app_definitions is services.app_definitions+ runtime = services.installed_app_generation._runtime+ assert isinstance(runtime, InstalledAppGenerateServiceRuntime)+ assert runtime._session_factory is sqlite_session_factory++@pytest.mark.parametrize(("deployment_edition", "setup_completed"),[diff --git a/api/tests/unit_tests/repositories/app/test_api_key_repository.py b/api/tests/unit_tests/repositories/app/test_api_key_repository.pynew file mode 100644index 00000000000..b63a5bc3b89--- /dev/null+++ b/api/tests/unit_tests/repositories/app/test_api_key_repository.py@@ -0,0 +1,85 @@+"""Real persistence checks for the resource API key boundary."""++import pytest+from sqlalchemy.orm import Session, sessionmaker++from models.enums import ApiTokenType+from models.model import ApiToken, App, AppMode+from repositories.app.api_key_repository import AppApiKeyRepository+from services.auth.api_key_contracts import (+ ApiKeyLimitExceededError,+ ApiKeyNotFoundError,+ ApiKeyResourceNotFoundError,+)+++def repository(sqlite_session: Session, sqlite_session_factory: sessionmaker[Session]) -> AppApiKeyRepository:+ sqlite_session.add_all(+ [+ App(id="app", tenant_id="tenant", name="App", mode=AppMode.CHAT, enable_site=False, enable_api=True),+ App(+ id="other-app", tenant_id="tenant", name="Other", mode=AppMode.CHAT, enable_site=False, enable_api=True+ ),+ ]+ )+ sqlite_session.commit()+ return AppApiKeyRepository(session_factory=sqlite_session_factory)+++def test_app_key_list_and_delete_preserve_owner_chain(repository: AppApiKeyRepository, sqlite_session: Session) -> None:+ sqlite_session.add_all(+ [+ ApiToken(id="current", type=ApiTokenType.APP, token="current", tenant_id="tenant", app_id="app"),+ ApiToken(id="historical", type=ApiTokenType.APP, token="historical", tenant_id=None, app_id="app"),+ ApiToken(id="foreign", type=ApiTokenType.APP, token="foreign", tenant_id="foreign", app_id="app"),+ ApiToken(id="other", type=ApiTokenType.APP, token="other", tenant_id="tenant", app_id="other-app"),+ ApiToken(id="wrong-type", type=ApiTokenType.DATASET, token="dataset", tenant_id="tenant", app_id="app"),+ ]+ )+ sqlite_session.commit()+ assert {key.id for key in repository.list_keys("tenant", "app")} == {"current", "historical"}+ for key_id in ["foreign", "other", "wrong-type", "missing"]:+ with pytest.raises(ApiKeyNotFoundError):+ repository.delete_key("tenant", "app", key_id)+ deleted = repository.delete_key("tenant", "app", "historical")+ assert deleted.token == "historical"+ assert sqlite_session.get(ApiToken, "historical") is None+ assert sqlite_session.get(ApiToken, "foreign") is not None++[email protected]("operation", ["list", "create", "delete"])+def test_resource_must_belong_to_workspace(repository: AppApiKeyRepository, operation: str) -> None:+ def invoke() -> object:+ if operation == "list":+ return repository.list_keys("foreign", "app")+ if operation == "create":+ return repository.create_key("foreign", "app", max_keys=10, prefix="test-")+ return repository.delete_key("foreign", "app", "missing")++ with pytest.raises(ApiKeyResourceNotFoundError):+ invoke()+++def test_creation_counts_historical_keys_but_not_foreign_keys(+ repository: AppApiKeyRepository,+ sqlite_session: Session,+) -> None:+ sqlite_session.add_all(+ [ApiToken(type=ApiTokenType.APP, token=f"foreign-{i}", tenant_id="foreign", app_id="app") for i in range(10)]+ )+ sqlite_session.add_all(+ [ApiToken(type=ApiTokenType.APP, token=f"historical-{i}", tenant_id=None, app_id="app") for i in range(9)]+ )+ sqlite_session.commit()++ created = repository.create_key("tenant", "app", max_keys=10, prefix="app-")+ assert created.token.startswith("app-")+ assert len(created.token) == 28+ assert created.created_at is not None+ with pytest.raises(ApiKeyLimitExceededError):+ repository.create_key("tenant", "app", max_keys=10, prefix="app-")+ stored = sqlite_session.get(ApiToken, created.id)+ assert stored is not None+ assert (stored.tenant_id, stored.app_id, stored.type) == ("tenant", "app", ApiTokenType.APP)+ assert len(repository.list_keys("tenant", "app")) == 10diff --git a/api/tests/unit_tests/repositories/knowledge/__init__.py b/api/tests/unit_tests/repositories/knowledge/__init__.pynew file mode 100644index 00000000000..e69de29bb2ddiff --git a/api/tests/unit_tests/services/test_dataset_api_key_service.py b/api/tests/unit_tests/repositories/knowledge/test_dataset_api_key_bindings.pysimilarity index 83%rename from api/tests/unit_tests/services/test_dataset_api_key_service.pyrename to api/tests/unit_tests/repositories/knowledge/test_dataset_api_key_bindings.pyindex f1f31fab09a..7b410856680 100644--- a/api/tests/unit_tests/services/test_dataset_api_key_service.py+++ b/api/tests/unit_tests/repositories/knowledge/test_dataset_api_key_bindings.py@@ -1,4 +1,4 @@-"""Unit tests for dataset API key scoping helpers."""+"""Persistence tests for dataset API key scoping and deletion."""import uuid@@ -7,7 +7,7 @@ from sqlalchemy.orm import Sessionfrom models.enums import ApiTokenTypefrom models.model import ApiToken, DatasetApiTokenBinding-from services import dataset_api_key_service+from repositories.knowledge import dataset_api_key_bindingsdef _dataset_token(session: Session) -> ApiToken:@@ -28,7 +28,7 @@ class TestDeleteKeysScopedOnlyTo:sqlite_session.add(DatasetApiTokenBinding(api_token_id=token.id, dataset_id=dataset_id))sqlite_session.commit()- deleted = dataset_api_key_service.delete_keys_scoped_only_to(sqlite_session, dataset_id)+ deleted = dataset_api_key_bindings.delete_keys_scoped_only_to(sqlite_session, dataset_id)sqlite_session.commit()assert deleted == [token.id]@@ -42,7 +42,7 @@ class TestDeleteKeysScopedOnlyTo:sqlite_session.add(DatasetApiTokenBinding(api_token_id=token.id, dataset_id=other_dataset_id))sqlite_session.commit()- deleted = dataset_api_key_service.delete_keys_scoped_only_to(sqlite_session, dataset_id)+ deleted = dataset_api_key_bindings.delete_keys_scoped_only_to(sqlite_session, dataset_id)sqlite_session.commit()# The key is bound elsewhere, so it survives and stays scoped.@@ -55,7 +55,7 @@ class TestDeleteKeysScopedOnlyTo:unbound = _dataset_token(sqlite_session)sqlite_session.commit()- deleted = dataset_api_key_service.delete_keys_scoped_only_to(sqlite_session, dataset_id)+ deleted = dataset_api_key_bindings.delete_keys_scoped_only_to(sqlite_session, dataset_id)sqlite_session.commit()assert deleted == []diff --git a/api/tests/unit_tests/repositories/knowledge/test_dataset_api_key_repository.py b/api/tests/unit_tests/repositories/knowledge/test_dataset_api_key_repository.pynew file mode 100644index 00000000000..c25ecb709ac--- /dev/null+++ b/api/tests/unit_tests/repositories/knowledge/test_dataset_api_key_repository.py@@ -0,0 +1,150 @@+"""Real persistence checks for the resource API key boundary."""++from functools import partial++import pytest+from sqlalchemy import select+from sqlalchemy.orm import Session, sessionmaker++from models.account import Tenant+from models.dataset import Dataset+from models.enums import ApiTokenType+from models.model import ApiToken, DatasetApiTokenBinding+from repositories.knowledge import dataset_api_key_bindings+from repositories.knowledge.dataset_api_key_repository import DatasetApiKeyRepository+from services.auth.api_key_contracts import (+ ApiKeyLimitExceededError,+ ApiKeyNotFoundError,+ ApiKeyResourceNotFoundError,+)+from services.knowledge.api_key_service import UnknownDatasetIdsError+++def repository(sqlite_session: Session, sqlite_session_factory: sessionmaker[Session]) -> DatasetApiKeyRepository:+ tenant = Tenant(name="Workspace")+ tenant.id = "tenant"+ sqlite_session.add(tenant)+ sqlite_session.add_all(+ [+ Dataset(id="dataset", tenant_id="tenant", name="Dataset", created_by="actor"),+ Dataset(id="other-dataset", tenant_id="tenant", name="Other dataset", created_by="actor"),+ ]+ )+ sqlite_session.commit()+ return DatasetApiKeyRepository(session_factory=sqlite_session_factory)++[email protected]("operation", ["list", "create", "delete"])+def test_resource_must_belong_to_workspace(repository: DatasetApiKeyRepository, operation: str) -> None:+ def invoke() -> object:+ if operation == "list":+ return repository.list_keys("foreign", "dataset")+ if operation == "create":+ return repository.create_key("foreign", "dataset", max_keys=10, prefix="test-")+ return repository.delete_key("foreign", "dataset", "missing")++ with pytest.raises(ApiKeyResourceNotFoundError):+ invoke()+++def test_dataset_keys_use_persisted_bindings_and_cannot_manage_broader_scopes(+ repository: DatasetApiKeyRepository,+ sqlite_session: Session,+) -> None:+ created = repository.create_key("tenant", "dataset", max_keys=10, prefix="ds-")+ assert created.dataset_ids == ("dataset",)+ assert created.token.startswith("ds-")+ assert (+ sqlite_session.scalar(+ select(DatasetApiTokenBinding.dataset_id).where(DatasetApiTokenBinding.api_token_id == created.id)+ )+ == "dataset"+ )+ scopes: list[tuple[str, list[str], str]] = [+ ("unrestricted", [], "tenant"),+ ("multiple", ["dataset", "other-dataset"], "tenant"),+ ("foreign", ["dataset"], "foreign"),+ ("other", ["other-dataset"], "tenant"),+ ]+ for key_id, dataset_ids, tenant_id in scopes:+ sqlite_session.add(ApiToken(id=key_id, type=ApiTokenType.DATASET, token=key_id, tenant_id=tenant_id))+ sqlite_session.add_all(DatasetApiTokenBinding(api_token_id=key_id, dataset_id=value) for value in dataset_ids)+ sqlite_session.commit()++ assert repository.list_keys("tenant", "dataset") == (created,)+ for key_id in ["unrestricted", "multiple", "foreign", "other"]:+ with pytest.raises(ApiKeyNotFoundError):+ repository.delete_key("tenant", "dataset", key_id)+ with pytest.raises(ApiKeyLimitExceededError):+ repository.create_key("tenant", "dataset", max_keys=1, prefix="ds-")+ repository.delete_key("tenant", "dataset", created.id)+ assert repository.list_keys("tenant", "dataset") == ()++[email protected]("workspace", [False, True])+def test_failed_binding_rolls_back_the_new_token(+ repository: DatasetApiKeyRepository, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch, workspace: bool+) -> None:+ def fail_binding(_session: Session, _api_token_id: str, _dataset_ids: object) -> None:+ raise RuntimeError("binding write failed")++ monkeypatch.setattr(dataset_api_key_bindings, "bind_datasets", fail_binding)+ create_key = (+ partial(repository.create_workspace_key, "tenant", ("dataset",), max_keys=10, prefix="dataset-")+ if workspace+ else partial(repository.create_key, "tenant", "dataset", max_keys=10, prefix="ds-")+ )+ with pytest.raises(RuntimeError, match="binding write failed"):+ create_key()++ assert sqlite_session.scalar(select(ApiToken)) is None++[email protected]("scope", [(), ("other-dataset",), ("dataset", "other-dataset")])[email protected]("workspace_creates_last", [False, True])+def test_both_scopes_share_the_workspace_quota(+ repository: DatasetApiKeyRepository,+ sqlite_session: Session,+ scope: tuple[str, ...],+ workspace_creates_last: bool,+) -> None:+ # Neither another tenant's keys nor app keys consume the dataset quota.+ sqlite_session.add_all(+ [ApiToken(tenant_id="foreign", type=ApiTokenType.DATASET, token=f"foreign-{i}") for i in range(10)]+ + [ApiToken(tenant_id="tenant", type=ApiTokenType.APP, token=f"app-{i}") for i in range(10)]+ )+ sqlite_session.commit()+ for _ in range(9):+ repository.create_workspace_key("tenant", scope, max_keys=10, prefix="dataset-")++ if workspace_creates_last:+ repository.create_workspace_key("tenant", scope, max_keys=10, prefix="dataset-")+ else:+ repository.create_key("tenant", "dataset", max_keys=10, prefix="ds-")++ with pytest.raises(ApiKeyLimitExceededError):+ repository.create_key("tenant", "dataset", max_keys=10, prefix="ds-")+ with pytest.raises(ApiKeyLimitExceededError):+ repository.create_workspace_key("tenant", (), max_keys=10, prefix="dataset-")+ assert len(repository.list_workspace_keys("tenant")) == 10+++def test_workspace_operations_preserve_scope_and_tenant(+ repository: DatasetApiKeyRepository, sqlite_session: Session+) -> None:+ sqlite_session.add(Dataset(id="foreign-dataset", tenant_id="foreign", name="Foreign", created_by="actor"))+ sqlite_session.commit()+ with pytest.raises(UnknownDatasetIdsError):+ repository.create_workspace_key("tenant", ("dataset", "foreign-dataset"), max_keys=10, prefix="dataset-")+ assert sqlite_session.scalar(select(ApiToken)) is None++ key = repository.create_workspace_key("tenant", ("dataset", "other-dataset"), max_keys=10, prefix="dataset-")+ listed = repository.list_workspace_keys("tenant")+ assert len(listed) == 1+ assert set(listed[0].dataset_ids) == {"dataset", "other-dataset"}+ assert repository.list_workspace_keys("foreign") == ()+ with pytest.raises(ApiKeyNotFoundError):+ repository.delete_workspace_key("foreign", key.id)+ repository.delete_workspace_key("tenant", key.id)+ assert repository.list_workspace_keys("tenant") == ()diff --git a/api/tests/unit_tests/services/app/test_api_key_service.py b/api/tests/unit_tests/services/app/test_api_key_service.pynew file mode 100644index 00000000000..ffd0bc849b9--- /dev/null+++ b/api/tests/unit_tests/services/app/test_api_key_service.py@@ -0,0 +1,204 @@+from dataclasses import dataclass, field++import pytest+from sqlalchemy import select+from sqlalchemy.orm import Session, sessionmaker++from extensions.application_services.app import build_app_api_key_service+from machinery.context import RequestContext+from models.agent import Agent, AgentConfigRevision, AgentConfigRevisionOperation, AgentScope, AgentSource, AgentStatus+from models.model import ApiToken, App, AppMode+from repositories.app.api_key_repository import AppApiKeyRepository+from services.app.api_key_service import AppApiKeyNotReadyError, AppApiKeyService+from services.auth.api_key_contracts import ApiKeyNotFoundError, ApiKeyResourceNotFoundError+++@dataclass+class ObservingCache:+ session_factory: sessionmaker[Session]+ calls: list[tuple[str, str | None]] = field(default_factory=list)++ def delete(self, token: str, scope: str | None = None) -> bool:+ # A fresh connection must see the deletion before any external cache I/O.+ with self.session_factory() as session:+ assert session.scalar(select(ApiToken).where(ApiToken.token == token)) is None+ self.calls.append((token, scope))+ return True+++def test_deletion_invalidates_cache_after_commit_and_not_on_failure(+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ sqlite_session.add(+ App(id="app", tenant_id="tenant", name="App", mode=AppMode.CHAT, enable_site=False, enable_api=True)+ )+ sqlite_session.commit()+ context = RequestContext("request", None, "actor", "tenant")+ cache = ObservingCache(sqlite_session_factory)+ service = AppApiKeyService(+ keys=AppApiKeyRepository(session_factory=sqlite_session_factory),+ cache=cache,+ )+ key = service.create_key(context, "app")++ with pytest.raises(ApiKeyNotFoundError):+ service.delete_key(context, "app", "missing")+ assert cache.calls == []++ service.delete_key(context, "app", key.id)+ assert cache.calls == [(key.token, key.type)]+ assert service.list_keys(context, "app") == ()+++def test_composition_builds_working_api_key_service(+ sqlite_session: Session, sqlite_session_factory: sessionmaker[Session]+) -> None:+ sqlite_session.add(+ App(id="app", tenant_id="tenant", name="App", mode=AppMode.CHAT, enable_site=False, enable_api=True)+ )+ sqlite_session.commit()+ service = build_app_api_key_service(database_client=sqlite_session_factory)+ context = RequestContext("request", None, "actor", "tenant")++ key = service.create_key(context, "app")+ assert service.list_keys(context, "app") == (key,)+++def service(sqlite_session: Session, sqlite_session_factory: sessionmaker[Session]) -> AppApiKeyService:+ sqlite_session.add(+ App(id="app", tenant_id="tenant", name="App", mode=AppMode.CHAT, enable_site=False, enable_api=True)+ )+ sqlite_session.commit()+ return build_app_api_key_service(database_client=sqlite_session_factory)+++def _persist_agent(session: Session) -> Agent:+ app = session.get(App, "app")+ assert app is not None+ app.mode = AppMode.AGENT+ agent = Agent(+ id="agent",+ tenant_id="tenant",+ name="Agent",+ scope=AgentScope.ROSTER,+ source=AgentSource.AGENT_APP,+ status=AgentStatus.ACTIVE,+ app_id="app",+ )+ session.add(agent)+ session.commit()+ return agent+++def test_app_access_check_rejects_foreign_workspace(service: AppApiKeyService, sqlite_session: Session) -> None:+ context = RequestContext("request", None, "actor", "foreign")++ with pytest.raises(ApiKeyResourceNotFoundError, match="App not found"):+ service.create_key(context, "app")++ assert sqlite_session.scalar(select(ApiToken)) is None++[email protected]("source", [AgentSource.AGENT_APP, AgentSource.IMPORTED])+def test_agent_requires_publish_visible_version_for_creation(+ service: AppApiKeyService,+ sqlite_session: Session,+ source: AgentSource,+) -> None:+ context = RequestContext("request", None, "actor", "tenant")+ agent = _persist_agent(sqlite_session)+ agent.source = source+ sqlite_session.commit()+ with pytest.raises(AppApiKeyNotReadyError):+ service.create_key(context, "app")+ with pytest.raises(AppApiKeyNotReadyError):+ service.create_agent_key(context, "agent")+ assert sqlite_session.scalar(select(ApiToken)) is None++ agent.active_config_snapshot_id = "snapshot"+ agent.active_config_is_published = False # New draft edits must not revoke a published version.+ sqlite_session.add(+ AgentConfigRevision(+ tenant_id="tenant",+ agent_id=agent.id,+ current_snapshot_id="snapshot",+ revision=1,+ operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,+ )+ )+ sqlite_session.commit()+ created = service.create_agent_key(context, "agent")+ assert service.list_agent_keys(context, "agent") == (created,)+ assert service.list_keys(context, "app") == (created,)++ agent.active_config_snapshot_id = None+ sqlite_session.commit()+ assert service.list_agent_keys(context, "agent") == (created,)+ service.delete_agent_key(context, "agent", created.id)+ assert service.list_agent_keys(context, "agent") == ()++[email protected]("invalid_revision", ["tenant", "agent", "snapshot", "unpublished"])+def test_creation_requires_a_publish_revision_for_the_owned_active_snapshot(+ service: AppApiKeyService, sqlite_session: Session, invalid_revision: str+) -> None:+ context = RequestContext("request", None, "actor", "tenant")+ agent = _persist_agent(sqlite_session)+ agent.active_config_snapshot_id = "snapshot"+ agent.active_config_is_published = True+ revision = AgentConfigRevision(+ tenant_id="tenant",+ agent_id="agent",+ current_snapshot_id="snapshot",+ revision=1,+ operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,+ )+ match invalid_revision:+ case "tenant":+ revision.tenant_id = "foreign"+ case "agent":+ revision.agent_id = "other-agent"+ case "snapshot":+ revision.current_snapshot_id = "old-snapshot"+ case "unpublished":+ revision.operation = AgentConfigRevisionOperation.IMPORT_PACKAGE+ sqlite_session.add(revision)+ sqlite_session.commit()++ with pytest.raises(AppApiKeyNotReadyError):+ service.create_key(context, "app")+ with pytest.raises(AppApiKeyNotReadyError):+ service.create_agent_key(context, "agent")+ assert sqlite_session.scalar(select(ApiToken)) is None+++ "invalid_state", ["tenant", "archived", "scope", "source", "app-tenant", "missing-app", "app-mode"]+)+def test_agent_resolution_checks_entire_owner_chain(+ service: AppApiKeyService, sqlite_session: Session, invalid_state: str+) -> None:+ context = RequestContext("request", None, "actor", "tenant")+ agent = _persist_agent(sqlite_session)+ app = sqlite_session.get(App, "app")+ assert app is not None+ match invalid_state:+ case "tenant":+ agent.tenant_id = "foreign"+ case "archived":+ agent.status = AgentStatus.ARCHIVED+ case "scope":+ agent.scope = AgentScope.WORKFLOW_ONLY+ case "source":+ agent.source = AgentSource.ROSTER+ case "app-tenant":+ app.tenant_id = "foreign"+ case "missing-app":+ agent.app_id = "missing"+ case "app-mode":+ app.mode = AppMode.CHAT+ sqlite_session.commit()+ with pytest.raises(ApiKeyResourceNotFoundError, match="Agent not found"):+ service.list_agent_keys(context, "agent")diff --git a/api/tests/unit_tests/services/knowledge/__init__.py b/api/tests/unit_tests/services/knowledge/__init__.pynew file mode 100644index 00000000000..e69de29bb2ddiff --git a/api/tests/unit_tests/services/knowledge/test_api_key_service.py b/api/tests/unit_tests/services/knowledge/test_api_key_service.pynew file mode 100644index 00000000000..f725f387de4--- /dev/null+++ b/api/tests/unit_tests/services/knowledge/test_api_key_service.py@@ -0,0 +1,154 @@+"""Knowledge key composition and post-commit cache invalidation."""++from collections.abc import Callable+from functools import partial++import pytest+from sqlalchemy import select+from sqlalchemy.orm import Session, sessionmaker++from extensions.application_services.knowledge import build_dataset_api_key_service+from machinery.context import RequestContext+from models.account import Tenant, TenantAccountJoin, TenantAccountRole+from models.dataset import Dataset, DatasetPermission+from models.enums import PermissionEnum+from models.model import ApiToken+from services.api_token_service import ApiTokenCache+from services.auth.api_key_contracts import ApiKeyNotFoundError+from services.errors.account import NoPermissionError+from services.knowledge.api_key_service import DatasetApiKeyService+++def service(+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+ config_overrides: Callable[..., None],+) -> DatasetApiKeyService:+ config_overrides(RBAC_ENABLED=False)+ tenant = Tenant(name="Workspace")+ tenant.id = "tenant"+ sqlite_session.add_all(+ [+ tenant,+ TenantAccountJoin(tenant_id="tenant", account_id="actor", role=TenantAccountRole.OWNER),+ Dataset(id="dataset", tenant_id="tenant", name="Dataset", created_by="actor", maintainer="maintainer"),+ ]+ )+ sqlite_session.commit()+ return build_dataset_api_key_service(database_client=sqlite_session_factory)++[email protected]("workspace", [False, True])+def test_dataset_keys_commit_before_invalidating_cache(+ service: DatasetApiKeyService,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+ workspace: bool,+) -> None:+ calls: list[tuple[str, str | None]] = []++ def invalidate(token: str, scope: str | None = None) -> bool:+ with sqlite_session_factory() as session:+ assert session.scalar(select(ApiToken).where(ApiToken.token == token)) is None+ calls.append((token, scope))+ return True++ monkeypatch.setattr(ApiTokenCache, "delete", invalidate)+ context = RequestContext("request", None, "actor", "tenant")++ key = (+ service.create_workspace_key(context, ("dataset", "dataset"))+ if workspace+ else service.create_key(context, "dataset")+ )+ assert key.token.startswith("dataset-" if workspace else "ds-")+ assert key.dataset_ids == ("dataset",)+ assert service.list_keys(context, "dataset") == (key,)++ delete_key = (+ partial(service.delete_workspace_key, context) if workspace else partial(service.delete_key, context, "dataset")+ )+ with pytest.raises(ApiKeyNotFoundError):+ delete_key("missing")+ assert calls == []++ delete_key(key.id)+ assert calls == [(key.token, key.type)]+ assert service.list_keys(context, "dataset") == ()+++ ("permission", "role", "maintainer", "grant", "allowed"),+ [+ (PermissionEnum.ONLY_ME, TenantAccountRole.EDITOR, "other", None, False),+ (PermissionEnum.ONLY_ME, TenantAccountRole.ADMIN, "other", None, False),+ (PermissionEnum.ONLY_ME, TenantAccountRole.OWNER, "other", None, True),+ (PermissionEnum.ONLY_ME, TenantAccountRole.EDITOR, "actor", None, True),+ (PermissionEnum.PARTIAL_TEAM, TenantAccountRole.EDITOR, "other", None, False),+ (PermissionEnum.PARTIAL_TEAM, TenantAccountRole.EDITOR, "other", "allowed", True),+ (PermissionEnum.PARTIAL_TEAM, TenantAccountRole.EDITOR, "actor", None, True),+ (PermissionEnum.PARTIAL_TEAM, TenantAccountRole.EDITOR, "other", "revoked", False),+ (PermissionEnum.PARTIAL_TEAM, TenantAccountRole.EDITOR, "other", "foreign", False),+ (PermissionEnum.ALL_TEAM, TenantAccountRole.EDITOR, "other", None, True),+ ],+)+def test_dataset_acl_controls_key_management(+ service: DatasetApiKeyService,+ sqlite_session: Session,+ permission: PermissionEnum,+ role: TenantAccountRole,+ maintainer: str,+ grant: str | None,+ allowed: bool,+) -> None:+ dataset = sqlite_session.get(Dataset, "dataset")+ member = sqlite_session.scalar(select(TenantAccountJoin))+ assert dataset is not None+ assert member is not None+ dataset.permission = permission+ dataset.maintainer = maintainer+ member.role = role+ if grant:+ sqlite_session.add(+ DatasetPermission(+ dataset_id="dataset",+ account_id="actor",+ tenant_id="foreign" if grant == "foreign" else "tenant",+ has_permission=grant != "revoked",+ )+ )+ sqlite_session.commit()+ context = RequestContext("request", None, "actor", "tenant")++ if allowed:+ key = service.create_key(context, "dataset")+ assert service.list_keys(context, "dataset") == (key,)+ else:+ with pytest.raises(NoPermissionError):+ service.create_key(context, "dataset")+ with pytest.raises(NoPermissionError):+ service.list_keys(context, "dataset")+ with pytest.raises(NoPermissionError):+ service.delete_key(context, "dataset", "missing")+ assert sqlite_session.scalar(select(ApiToken)) is None+++def test_acl_requires_membership_in_the_active_workspace(+ service: DatasetApiKeyService, sqlite_session: Session+) -> None:+ member = sqlite_session.scalar(select(TenantAccountJoin))+ assert member is not None+ member.tenant_id = "foreign"+ sqlite_session.commit()+ with pytest.raises(NoPermissionError):+ service.create_key(RequestContext("request", None, "actor", "tenant"), "dataset")+ assert sqlite_session.scalar(select(ApiToken)) is None+++def test_rbac_admitted_request_uses_rbac_instead_of_community_acl(+ service: DatasetApiKeyService, config_overrides: Callable[..., None]+) -> None:+ config_overrides(RBAC_ENABLED=True)+ key = service.create_key(RequestContext("request", None, "rbac-actor", "tenant"), "dataset")+ assert key.dataset_ids == ("dataset",)diff --git a/api/tests/unit_tests/services/test_app_service.py b/api/tests/unit_tests/services/test_app_service.pyindex 5299d75c1c4..d95ec76547b 100644--- a/api/tests/unit_tests/services/test_app_service.py+++ b/api/tests/unit_tests/services/test_app_service.py@@ -418,9 +418,8 @@ def test_unpublished_agent_app_access_cannot_be_enabled(commits: list[str] = []event.listen(sqlite_session, "after_commit", lambda _session: commits.append("commit"))- with patch("services.app_service.agent_has_workflow_callable_active_snapshot", return_value=False):- with pytest.raises(AgentAccessNotReadyError):- update_status(AppService(), app, True, session=sqlite_session)+ with pytest.raises(AgentAccessNotReadyError):+ update_status(AppService(), app, True, session=sqlite_session)assert app.enable_site is Falseassert app.enable_api is Falsediff --git a/packages/contracts/generated/api/console/apps/orpc.gen.ts b/packages/contracts/generated/api/console/apps/orpc.gen.tsindex a34b647f07b..d775a9aec11 100644--- a/packages/contracts/generated/api/console/apps/orpc.gen.ts+++ b/packages/contracts/generated/api/console/apps/orpc.gen.ts@@ -4498,8 +4498,6 @@ export const byAppId2 = {}/**- * Delete an API key for an app- ** Delete an API key for an app*/export const delete16 = oc@@ -4510,7 +4508,6 @@ export const delete16 = ocoperationId: 'deleteAppsByResourceIdApiKeysByApiKeyId',path: '/apps/{resource_id}/api-keys/{api_key_id}',successStatus: 204,- summary: 'Delete an API key for an app',tags: ['console'],}).input(z.object({ params: zDeleteAppsByResourceIdApiKeysByApiKeyIdPath }))@@ -4521,8 +4518,6 @@ export const byApiKeyId = {}/**- * Get all API keys for an app- ** Get all API keys for an app*/export const get85 = oc@@ -4532,15 +4527,12 @@ export const get85 = ocmethod: 'GET',operationId: 'getAppsByResourceIdApiKeys',path: '/apps/{resource_id}/api-keys',- summary: 'Get all API keys for an app',tags: ['console'],}).input(z.object({ params: zGetAppsByResourceIdApiKeysPath })).output(zGetAppsByResourceIdApiKeysResponse)/**- * Create a new API key for an app- ** Create a new API key for an app*/export const post63 = oc@@ -4551,7 +4543,6 @@ export const post63 = ocoperationId: 'postAppsByResourceIdApiKeys',path: '/apps/{resource_id}/api-keys',successStatus: 201,- summary: 'Create a new API key for an app',tags: ['console'],}).input(z.object({ params: zPostAppsByResourceIdApiKeysPath }))diff --git a/packages/contracts/generated/api/console/datasets/orpc.gen.ts b/packages/contracts/generated/api/console/datasets/orpc.gen.tsindex 2f4cb4b31ef..2cbafe6d030 100644--- a/packages/contracts/generated/api/console/datasets/orpc.gen.ts+++ b/packages/contracts/generated/api/console/datasets/orpc.gen.ts@@ -1698,8 +1698,6 @@ export const byDatasetId = {}/**- * Delete an API key for a dataset- ** Delete an API key for a dataset*/export const delete10 = oc@@ -1710,7 +1708,6 @@ export const delete10 = ocoperationId: 'deleteDatasetsByResourceIdApiKeysByApiKeyId',path: '/datasets/{resource_id}/api-keys/{api_key_id}',successStatus: 204,- summary: 'Delete an API key for a dataset',tags: ['console'],}).input(z.object({ params: zDeleteDatasetsByResourceIdApiKeysByApiKeyIdPath }))@@ -1721,8 +1718,6 @@ export const byApiKeyId2 = {}/**- * Get all API keys for a dataset- ** Get all API keys for a dataset*/export const get35 = oc@@ -1732,15 +1727,12 @@ export const get35 = ocmethod: 'GET',operationId: 'getDatasetsByResourceIdApiKeys',path: '/datasets/{resource_id}/api-keys',- summary: 'Get all API keys for a dataset',tags: ['console'],}).input(z.object({ params: zGetDatasetsByResourceIdApiKeysPath })).output(zGetDatasetsByResourceIdApiKeysResponse)/**- * Create a new API key for a dataset- ** Create a new API key for a dataset*/export const post22 = oc@@ -1751,7 +1743,6 @@ export const post22 = ocoperationId: 'postDatasetsByResourceIdApiKeys',path: '/datasets/{resource_id}/api-keys',successStatus: 201,- summary: 'Create a new API key for a dataset',tags: ['console'],}).input(z.object({ params: zPostDatasetsByResourceIdApiKeysPath }))