chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
1 parent 60158935f4
commit 6519682885
15831 files changed
+3063428

No files matched your search

@@ -0,0 +1,3 @@
from . import composer, roster
__all__ = ["composer", "roster"]
@@ -0,0 +1,21 @@
from uuid import UUID
from sqlalchemy.orm import Session
from models.model import App
from services.agent.roster_service import AgentRosterService
def resolve_agent_runtime_app_model(*, session: Session, tenant_id: str, agent_id: UUID) -> App:
"""Resolve the App that backs an Agent runtime surface.
This accepts both roster Agent Apps and workflow-only inline Agents with a
hidden backing App.
"""
return AgentRosterService(session).get_agent_runtime_app_model(tenant_id=tenant_id, agent_id=str(agent_id))
def resolve_existing_agent_runtime_app_model(*, session: Session, tenant_id: str, agent_id: UUID) -> App:
"""Resolve persisted runtime state for read-only Agent endpoints."""
return AgentRosterService(session).get_existing_agent_runtime_app_model(tenant_id=tenant_id, agent_id=str(agent_id))
@@ -0,0 +1,654 @@
from uuid import UUID
from flask_restx import Resource
from sqlalchemy.orm import Session
from werkzeug.exceptions import NotFound
from controllers.common.rbac import AgentId, PlainApp, RBACCheck, Workspace
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
from controllers.common.session import with_session
from controllers.console import console_ns
from controllers.console.app.wraps import get_app_model
from controllers.console.wraps import (
RBACPermission,
account_initialization_required,
edit_permission_required,
model_validate,
rbac_permission_required,
setup_required,
with_current_tenant_id,
with_current_user_id,
)
from fields.agent_fields import (
AgentAppComposerResponse,
AgentComposerCandidatesResponse,
AgentComposerImpactResponse,
AgentComposerValidateResponse,
WorkflowAgentComposerResponse,
)
from libs.external_api import error_responses
from libs.helper import dump_response
from libs.login import login_required
from models.model import App, AppMode
from services.agent.composer_service import AgentComposerService
from services.agent.composer_validator import ComposerConfigValidator
from services.agent.errors import (
AgentNameConflictError,
AgentNotFoundError,
AgentSoulLockedError,
AgentVersionConflictError,
AgentVersionNotFoundError,
InvalidComposerConfigError,
PlaintextSecretNotAllowedError,
)
from services.entities.agent_entities import (
ComposerSavePayload,
WorkflowAgentComposerQuery,
WorkflowComposerCopyFromRosterPayload,
)
from services.snippet_service import SnippetService
register_schema_models(
console_ns, ComposerSavePayload, WorkflowAgentComposerQuery, WorkflowComposerCopyFromRosterPayload
)
register_response_schema_models(
console_ns,
AgentAppComposerResponse,
AgentComposerCandidatesResponse,
AgentComposerImpactResponse,
AgentComposerValidateResponse,
WorkflowAgentComposerResponse,
)
@console_ns.route("/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/agent-composer")
class WorkflowAgentComposerApi(Resource):
@error_responses(AgentNotFoundError, AgentVersionNotFoundError)
@console_ns.response(
200, "Workflow agent composer state", console_ns.models[WorkflowAgentComposerResponse.__name__]
)
@console_ns.doc(params=query_params_from_model(WorkflowAgentComposerQuery))
@setup_required
@login_required
@account_initialization_required
@with_current_user_id
@with_current_tenant_id
@with_session
@get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
@model_validate(WorkflowAgentComposerQuery)
def get(
self,
req_data: WorkflowAgentComposerQuery,
session: Session,
tenant_id: str,
account_id: str,
app_model: App,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.load_workflow_composer(
session=session,
tenant_id=tenant_id,
app_id=app_model.id,
node_id=node_id,
account_id=account_id,
snapshot_id=req_data.snapshot_id,
),
)
@error_responses(
AgentNameConflictError,
AgentNotFoundError,
AgentSoulLockedError,
AgentVersionNotFoundError,
InvalidComposerConfigError,
PlaintextSecretNotAllowedError,
)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(
200, "Workflow agent composer saved", console_ns.models[WorkflowAgentComposerResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@edit_permission_required
@rbac_permission_required(RBACCheck(RBACPermission.APP_EDIT, PlainApp()))
@with_current_user_id
@with_current_tenant_id
@with_session
@get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
@model_validate(ComposerSavePayload)
def put(
self,
req_data: ComposerSavePayload,
session: Session,
tenant_id: str,
account_id: str,
app_model: App,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.save_workflow_composer(
session=session,
tenant_id=tenant_id,
app_id=app_model.id,
node_id=node_id,
account_id=account_id,
payload=req_data,
),
)
@console_ns.route("/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/agent-composer/copy-from-roster")
class WorkflowAgentComposerCopyFromRosterApi(Resource):
@error_responses(
AgentNotFoundError, AgentVersionConflictError, AgentVersionNotFoundError, InvalidComposerConfigError
)
@console_ns.expect(console_ns.models[WorkflowComposerCopyFromRosterPayload.__name__])
@console_ns.response(
200,
"Workflow roster agent copied to inline agent",
console_ns.models[WorkflowAgentComposerResponse.__name__],
)
@setup_required
@login_required
@account_initialization_required
@edit_permission_required
@rbac_permission_required(RBACCheck(RBACPermission.APP_EDIT, PlainApp()))
@with_current_user_id
@with_current_tenant_id
@with_session
@get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
@model_validate(WorkflowComposerCopyFromRosterPayload)
def post(
self,
req_data: WorkflowComposerCopyFromRosterPayload,
session: Session,
tenant_id: str,
account_id: str,
app_model: App,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.copy_workflow_composer_from_roster(
session=session,
tenant_id=tenant_id,
app_id=app_model.id,
node_id=node_id,
account_id=account_id,
source_agent_id=req_data.source_agent_id,
source_snapshot_id=req_data.source_snapshot_id,
idempotency_key=req_data.idempotency_key,
),
)
@console_ns.route("/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/agent-composer/validate")
class WorkflowAgentComposerValidateApi(Resource):
@error_responses(AgentSoulLockedError, InvalidComposerConfigError, PlaintextSecretNotAllowedError)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(
200, "Workflow agent composer validation result", console_ns.models[AgentComposerValidateResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
@with_session(write=False)
@get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
@model_validate(ComposerSavePayload)
def post(self, req_data: ComposerSavePayload, session: Session, tenant_id: str, app_model: App, node_id: str):
ComposerConfigValidator.validate_publish_payload(req_data)
AgentComposerService.validate_knowledge_datasets(
session=session, tenant_id=tenant_id, agent_soul=req_data.agent_soul
)
findings = AgentComposerService.collect_validation_findings(payload=req_data)
return dump_response(AgentComposerValidateResponse, {"result": "success", "errors": [], **findings})
@console_ns.route("/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/agent-composer/candidates")
class WorkflowAgentComposerCandidatesApi(Resource):
@console_ns.response(
200, "Workflow agent composer candidates", console_ns.models[AgentComposerCandidatesResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user_id
@with_current_tenant_id
@with_session(write=False)
@get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
def get(self, session: Session, tenant_id: str, current_user_id: str, app_model: App, node_id: str):
return dump_response(
AgentComposerCandidatesResponse,
AgentComposerService.get_workflow_candidates(
session=session,
tenant_id=tenant_id,
app_id=app_model.id,
node_id=node_id,
user_id=current_user_id,
),
)
@console_ns.route("/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/agent-composer/impact")
class WorkflowAgentComposerImpactApi(Resource):
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(200, "Workflow agent composer impact", console_ns.models[AgentComposerImpactResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
@with_session(write=False)
@get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
@model_validate(ComposerSavePayload)
def post(self, req_data: ComposerSavePayload, session: Session, tenant_id: str, app_model: App, node_id: str):
current_snapshot_id = req_data.binding.current_snapshot_id if req_data.binding else None
if not current_snapshot_id:
return dump_response(
AgentComposerImpactResponse, {"current_snapshot_id": None, "workflow_node_count": 0, "bindings": []}
)
return dump_response(
AgentComposerImpactResponse,
AgentComposerService.calculate_impact(
session=session, tenant_id=tenant_id, current_snapshot_id=current_snapshot_id
),
)
@console_ns.route("/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/agent-composer/save-to-roster")
class WorkflowAgentComposerSaveToRosterApi(Resource):
@error_responses(
AgentNameConflictError,
AgentNotFoundError,
AgentSoulLockedError,
AgentVersionNotFoundError,
InvalidComposerConfigError,
PlaintextSecretNotAllowedError,
)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(
200, "Workflow agent composer saved to roster", console_ns.models[WorkflowAgentComposerResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@edit_permission_required
@rbac_permission_required(RBACCheck(RBACPermission.APP_EDIT, PlainApp()))
@rbac_permission_required(RBACCheck(RBACPermission.AGENT_CREATE, Workspace()))
@with_current_user_id
@with_current_tenant_id
@with_session
@get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
@model_validate(ComposerSavePayload)
def post(
self,
req_data: ComposerSavePayload,
session: Session,
tenant_id: str,
account_id: str,
app_model: App,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.save_workflow_composer(
session=session,
tenant_id=tenant_id,
app_id=app_model.id,
node_id=node_id,
account_id=account_id,
payload=req_data,
),
)
def _require_snippet_app_id(*, session: Session, tenant_id: str, snippet_id: UUID) -> str:
snippet = SnippetService(session=session).get_snippet_by_id(
snippet_id=str(snippet_id), # pyrefly: ignore[unnecessary-type-conversion]
tenant_id=tenant_id,
)
if snippet is None:
raise NotFound("Snippet not found")
return snippet.id
@console_ns.route("/snippets/<uuid:snippet_id>/workflows/draft/nodes/<string:node_id>/agent-composer")
class SnippetAgentComposerApi(Resource):
@error_responses(AgentNotFoundError, AgentVersionNotFoundError)
@console_ns.response(200, "Snippet agent composer state", console_ns.models[WorkflowAgentComposerResponse.__name__])
@console_ns.doc(params=query_params_from_model(WorkflowAgentComposerQuery))
@setup_required
@login_required
@account_initialization_required
@with_current_user_id
@with_current_tenant_id
@with_session
@model_validate(WorkflowAgentComposerQuery)
def get(
self,
req_data: WorkflowAgentComposerQuery,
session: Session,
tenant_id: str,
account_id: str,
snippet_id: UUID,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.load_workflow_composer(
session=session,
tenant_id=tenant_id,
app_id=_require_snippet_app_id(session=session, tenant_id=tenant_id, snippet_id=snippet_id),
node_id=node_id,
account_id=account_id,
snapshot_id=req_data.snapshot_id,
),
)
@error_responses(
AgentNameConflictError,
AgentNotFoundError,
AgentSoulLockedError,
AgentVersionNotFoundError,
InvalidComposerConfigError,
PlaintextSecretNotAllowedError,
)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(200, "Snippet agent composer saved", console_ns.models[WorkflowAgentComposerResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@edit_permission_required
@rbac_permission_required(RBACCheck(RBACPermission.SNIPPETS_CREATE_AND_MODIFY, Workspace()))
@with_current_user_id
@with_current_tenant_id
@with_session
@model_validate(ComposerSavePayload)
def put(
self,
req_data: ComposerSavePayload,
session: Session,
tenant_id: str,
account_id: str,
snippet_id: UUID,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.save_workflow_composer(
session=session,
tenant_id=tenant_id,
app_id=_require_snippet_app_id(session=session, tenant_id=tenant_id, snippet_id=snippet_id),
node_id=node_id,
account_id=account_id,
payload=req_data,
),
)
@console_ns.route("/snippets/<uuid:snippet_id>/workflows/draft/nodes/<string:node_id>/agent-composer/copy-from-roster")
class SnippetAgentComposerCopyFromRosterApi(Resource):
@error_responses(
AgentNotFoundError, AgentVersionConflictError, AgentVersionNotFoundError, InvalidComposerConfigError
)
@console_ns.expect(console_ns.models[WorkflowComposerCopyFromRosterPayload.__name__])
@console_ns.response(
200, "Roster agent copied into snippet", console_ns.models[WorkflowAgentComposerResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@edit_permission_required
@rbac_permission_required(RBACCheck(RBACPermission.SNIPPETS_CREATE_AND_MODIFY, Workspace()))
@with_current_user_id
@with_current_tenant_id
@with_session
@model_validate(WorkflowComposerCopyFromRosterPayload)
def post(
self,
req_data: WorkflowComposerCopyFromRosterPayload,
session: Session,
tenant_id: str,
account_id: str,
snippet_id: UUID,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.copy_workflow_composer_from_roster(
session=session,
tenant_id=tenant_id,
app_id=_require_snippet_app_id(session=session, tenant_id=tenant_id, snippet_id=snippet_id),
node_id=node_id,
account_id=account_id,
source_agent_id=req_data.source_agent_id,
source_snapshot_id=req_data.source_snapshot_id,
idempotency_key=req_data.idempotency_key,
),
)
@console_ns.route("/snippets/<uuid:snippet_id>/workflows/draft/nodes/<string:node_id>/agent-composer/validate")
class SnippetAgentComposerValidateApi(Resource):
@error_responses(AgentSoulLockedError, InvalidComposerConfigError, PlaintextSecretNotAllowedError)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(
200, "Snippet agent composer validation", console_ns.models[AgentComposerValidateResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
@with_session(write=False)
@model_validate(ComposerSavePayload)
def post(self, req_data: ComposerSavePayload, session: Session, tenant_id: str, snippet_id: UUID, node_id: str):
_require_snippet_app_id(session=session, tenant_id=tenant_id, snippet_id=snippet_id)
ComposerConfigValidator.validate_publish_payload(req_data)
AgentComposerService.validate_knowledge_datasets(
session=session, tenant_id=tenant_id, agent_soul=req_data.agent_soul
)
findings = AgentComposerService.collect_validation_findings(payload=req_data)
return dump_response(AgentComposerValidateResponse, {"result": "success", "errors": [], **findings})
@console_ns.route("/snippets/<uuid:snippet_id>/workflows/draft/nodes/<string:node_id>/agent-composer/candidates")
class SnippetAgentComposerCandidatesApi(Resource):
@console_ns.response(
200, "Snippet agent composer candidates", console_ns.models[AgentComposerCandidatesResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@with_current_user_id
@with_current_tenant_id
@with_session(write=False)
def get(self, session: Session, tenant_id: str, current_user_id: str, snippet_id: UUID, node_id: str):
return dump_response(
AgentComposerCandidatesResponse,
AgentComposerService.get_workflow_candidates(
session=session,
tenant_id=tenant_id,
app_id=_require_snippet_app_id(session=session, tenant_id=tenant_id, snippet_id=snippet_id),
node_id=node_id,
user_id=current_user_id,
),
)
@console_ns.route("/snippets/<uuid:snippet_id>/workflows/draft/nodes/<string:node_id>/agent-composer/impact")
class SnippetAgentComposerImpactApi(Resource):
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(200, "Snippet agent composer impact", console_ns.models[AgentComposerImpactResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@with_current_tenant_id
@with_session(write=False)
@model_validate(ComposerSavePayload)
def post(self, req_data: ComposerSavePayload, session: Session, tenant_id: str, snippet_id: UUID, node_id: str):
_require_snippet_app_id(session=session, tenant_id=tenant_id, snippet_id=snippet_id)
current_snapshot_id = req_data.binding.current_snapshot_id if req_data.binding else None
if not current_snapshot_id:
return dump_response(
AgentComposerImpactResponse, {"current_snapshot_id": None, "workflow_node_count": 0, "bindings": []}
)
return dump_response(
AgentComposerImpactResponse,
AgentComposerService.calculate_impact(
session=session,
tenant_id=tenant_id,
current_snapshot_id=current_snapshot_id,
),
)
@console_ns.route("/snippets/<uuid:snippet_id>/workflows/draft/nodes/<string:node_id>/agent-composer/save-to-roster")
class SnippetAgentComposerSaveToRosterApi(Resource):
@error_responses(
AgentNameConflictError,
AgentNotFoundError,
AgentSoulLockedError,
AgentVersionNotFoundError,
InvalidComposerConfigError,
PlaintextSecretNotAllowedError,
)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(
200, "Snippet agent saved to roster", console_ns.models[WorkflowAgentComposerResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@edit_permission_required
@rbac_permission_required(RBACCheck(RBACPermission.SNIPPETS_CREATE_AND_MODIFY, Workspace()))
@rbac_permission_required(RBACCheck(RBACPermission.AGENT_CREATE, Workspace()))
@with_current_user_id
@with_current_tenant_id
@with_session
@model_validate(ComposerSavePayload)
def post(
self,
req_data: ComposerSavePayload,
session: Session,
tenant_id: str,
account_id: str,
snippet_id: UUID,
node_id: str,
):
return dump_response(
WorkflowAgentComposerResponse,
AgentComposerService.save_workflow_composer(
session=session,
tenant_id=tenant_id,
app_id=_require_snippet_app_id(session=session, tenant_id=tenant_id, snippet_id=snippet_id),
node_id=node_id,
account_id=account_id,
payload=req_data,
),
)
@console_ns.route("/agent/<uuid:agent_id>/composer")
class AgentComposerApi(Resource):
@error_responses(AgentNotFoundError, AgentVersionNotFoundError)
@console_ns.response(200, "Agent app composer state", console_ns.models[AgentAppComposerResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.AGENT_PREVIEW, AgentId()))
@with_current_tenant_id
@with_session(write=False)
def get(self, session: Session, tenant_id: str, agent_id: UUID):
return dump_response(
AgentAppComposerResponse,
AgentComposerService.load_agent_composer(session=session, tenant_id=tenant_id, agent_id=str(agent_id)),
)
@error_responses(
AgentNotFoundError,
AgentSoulLockedError,
AgentVersionNotFoundError,
InvalidComposerConfigError,
PlaintextSecretNotAllowedError,
)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(200, "Agent app composer saved", console_ns.models[AgentAppComposerResponse.__name__])
@setup_required
@login_required
@account_initialization_required
@edit_permission_required
@rbac_permission_required(RBACCheck(RBACPermission.AGENT_EDIT, AgentId()))
@with_current_user_id
@with_current_tenant_id
@with_session
@model_validate(ComposerSavePayload)
def put(self, req_data: ComposerSavePayload, session: Session, tenant_id: str, account_id: str, agent_id: UUID):
return dump_response(
AgentAppComposerResponse,
AgentComposerService.save_agent_composer(
session=session,
tenant_id=tenant_id,
agent_id=str(agent_id),
account_id=account_id,
payload=req_data,
),
)
@console_ns.route("/agent/<uuid:agent_id>/composer/validate")
class AgentComposerValidateApi(Resource):
@error_responses(
AgentNotFoundError,
AgentSoulLockedError,
AgentVersionNotFoundError,
InvalidComposerConfigError,
PlaintextSecretNotAllowedError,
)
@console_ns.expect(console_ns.models[ComposerSavePayload.__name__])
@console_ns.response(
200, "Agent app composer validation result", console_ns.models[AgentComposerValidateResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.AGENT_PREVIEW, AgentId()))
@with_current_tenant_id
@with_session(write=False)
@model_validate(ComposerSavePayload)
def post(self, req_data: ComposerSavePayload, session: Session, tenant_id: str, agent_id: UUID):
AgentComposerService.load_agent_composer(session=session, tenant_id=tenant_id, agent_id=str(agent_id))
ComposerConfigValidator.validate_publish_payload(req_data)
AgentComposerService.validate_knowledge_datasets(
session=session, tenant_id=tenant_id, agent_soul=req_data.agent_soul
)
findings = AgentComposerService.collect_validation_findings(payload=req_data)
return dump_response(AgentComposerValidateResponse, {"result": "success", "errors": [], **findings})
@console_ns.route("/agent/<uuid:agent_id>/composer/candidates")
class AgentComposerCandidatesApi(Resource):
@error_responses(AgentVersionNotFoundError)
@console_ns.response(
200, "Agent app composer candidates", console_ns.models[AgentComposerCandidatesResponse.__name__]
)
@setup_required
@login_required
@account_initialization_required
@rbac_permission_required(RBACCheck(RBACPermission.AGENT_PREVIEW, AgentId()))
@with_current_user_id
@with_current_tenant_id
@with_session(write=False)
def get(self, session: Session, tenant_id: str, current_user_id: str, agent_id: UUID):
return dump_response(
AgentComposerCandidatesResponse,
AgentComposerService.get_agent_app_candidates(
session=session,
tenant_id=tenant_id,
agent_id=str(agent_id),
user_id=current_user_id,
),
)
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,248 @@
"""Agent tracing settings address Agent resources, never hidden inline Apps."""
from collections.abc import Callable
from dataclasses import asdict
from typing import Literal
from uuid import UUID
from flask import request
from flask_restx import Resource
from pydantic import Field
from werkzeug.exceptions import NotFound
from controllers.common.rbac import AgentId, PlainApp, RBACCheck
from controllers.common.schema import query_params_from_model, register_response_schema_models
from controllers.console import console_ns
from controllers.console.app.app import AppTracePayload
from controllers.console.app.error import (
AppNotFoundError,
InvalidTracingConfigError,
TracingConfigAlreadyExistsError,
TracingConfigConflictError,
TracingConfigNotFoundError,
TracingConfigProcessingError,
TracingConfigVerificationFailedError,
TracingProviderUnavailableError,
UnsupportedTracingProviderError,
)
from controllers.console.app.ops_trace import TraceAppConfigResponse, TraceConfigPayload, TraceProviderQuery
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.app_fields import AppTraceResponse
from fields.base import ResponseModel
from libs.external_api import error_responses
from libs.helper import dump_response
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.app.agent_app_contracts import AgentAppNotFoundError
from services.app.console_service import ConsoleAppNotFoundError
from services.app_tracing_config_service import (
AppTraceSettings,
AppTracingConfigAlreadyExistsError,
AppTracingConfigAppNotFoundError,
AppTracingConfigConflictError,
AppTracingConfigInvalidConfigurationError,
AppTracingConfigInvalidProviderError,
AppTracingConfigNotFoundError,
AppTracingConfigProcessingError,
AppTracingConfigProviderUnavailableError,
AppTracingConfigVerificationFailedError,
)
_EDIT_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR})
class TraceProviderSupportResponse(ResponseModel):
"""Adapter support declarations, not successful-delivery or platform-verification results."""
provider: str
agent_spans: bool
session: bool
native_usage: bool
native_cost: bool
trace_url: bool
span_url: bool
export_ack: Literal["accepted"] = Field(description="Exporter acknowledgement does not confirm query visibility")
class TraceProviderCapabilitiesResponse(TraceProviderSupportResponse):
api_collection_enabled: bool = Field(
description="Current API collection gate only; does not probe Agent runtime or confirm delivery"
)
register_response_schema_models(console_ns, TraceProviderSupportResponse, TraceProviderCapabilitiesResponse)
def _tracing_call[T](call: Callable[[], T]) -> T:
"""Translate configuration-domain failures without returning credentials or provider errors."""
try:
return call()
except (AgentAppNotFoundError, ConsoleAppNotFoundError) as error:
raise NotFound("Agent not found") from error
except AppTracingConfigAppNotFoundError as error:
raise AppNotFoundError() from error
except AppTracingConfigAlreadyExistsError as error:
raise TracingConfigAlreadyExistsError() from error
except AppTracingConfigConflictError as error:
raise TracingConfigConflictError() from error
except AppTracingConfigNotFoundError as error:
raise TracingConfigNotFoundError() from error
except AppTracingConfigInvalidProviderError as error:
raise UnsupportedTracingProviderError() from error
except AppTracingConfigProviderUnavailableError as error:
raise TracingProviderUnavailableError() from error
except AppTracingConfigInvalidConfigurationError as error:
raise InvalidTracingConfigError() from error
except AppTracingConfigVerificationFailedError as error:
raise TracingConfigVerificationFailedError() from error
except AppTracingConfigProcessingError as error:
raise TracingConfigProcessingError() from error
@console_ns.route("/agent/<uuid:agent_id>/trace")
class AgentTraceApi(Resource):
@console_ns.doc("get_agent_trace")
@console_ns.response(200, "Agent tracing settings", console_ns.models[AppTraceResponse.__name__])
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.AGENT_MONITOR, AgentId())])
def get(self, context: RequestContext, agent_id: UUID):
settings = _tracing_call(lambda: application_services().agent_tracing_configs.get_trace(context, str(agent_id)))
return dump_response(AppTraceResponse, settings)
@error_responses(
TracingProviderUnavailableError,
TracingConfigNotFoundError,
TracingConfigConflictError,
InvalidTracingConfigError,
TracingConfigProcessingError,
UnsupportedTracingProviderError,
)
@console_ns.doc("update_agent_trace")
@console_ns.expect(console_ns.models[AppTracePayload.__name__])
@console_ns.response(200, "Updated Agent tracing settings", console_ns.models[AppTraceResponse.__name__])
@console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.AGENT_EDIT, AgentId())])
def post(self, context: RequestContext, agent_id: UUID):
payload = AppTracePayload.model_validate(console_ns.payload or {})
settings = AppTraceSettings(**payload.model_dump())
_tracing_call(lambda: application_services().agent_tracing_configs.set_trace(context, str(agent_id), settings))
return dump_response(AppTraceResponse, settings)
@console_ns.route("/agent/<uuid:agent_id>/trace-config")
class AgentTraceConfigApi(Resource):
@error_responses(
AppNotFoundError, TracingConfigProcessingError, TracingProviderUnavailableError, UnsupportedTracingProviderError
)
@console_ns.doc("get_agent_trace_config", params=query_params_from_model(TraceProviderQuery))
@console_ns.response(200, "Masked Agent provider configuration", console_ns.models[TraceAppConfigResponse.__name__])
@console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.AGENT_EDIT, AgentId())])
def get(self, context: RequestContext, agent_id: UUID):
query = TraceProviderQuery.model_validate(request.args.to_dict(flat=True))
record = _tracing_call(
lambda: application_services().agent_tracing_configs.get(context, str(agent_id), query.tracing_provider)
)
if record is None:
return dump_response(TraceAppConfigResponse, {"has_not_configured": True}, exclude_none=True)
return dump_response(TraceAppConfigResponse, TraceAppConfigResponse.from_record(record), exclude_none=True)
@error_responses(
AppNotFoundError,
InvalidTracingConfigError,
TracingConfigAlreadyExistsError,
TracingConfigProcessingError,
TracingConfigVerificationFailedError,
TracingProviderUnavailableError,
UnsupportedTracingProviderError,
)
@console_ns.doc("create_agent_trace_config")
@console_ns.expect(console_ns.models[TraceConfigPayload.__name__])
@console_ns.response(201, "Agent provider configured", console_ns.models[TraceAppConfigResponse.__name__])
@console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.AGENT_EDIT, AgentId())])
def post(self, context: RequestContext, agent_id: UUID):
payload = TraceConfigPayload.model_validate(console_ns.payload or {})
_tracing_call(
lambda: application_services().agent_tracing_configs.create(
context, str(agent_id), payload.tracing_provider, payload.tracing_config, activate=payload.activate
)
)
return dump_response(TraceAppConfigResponse, {"result": "success"}, exclude_none=True), 201
@error_responses(
AppNotFoundError,
InvalidTracingConfigError,
TracingConfigNotFoundError,
TracingConfigConflictError,
TracingConfigProcessingError,
TracingConfigVerificationFailedError,
TracingProviderUnavailableError,
UnsupportedTracingProviderError,
)
@console_ns.doc("update_agent_trace_config")
@console_ns.expect(console_ns.models[TraceConfigPayload.__name__])
@console_ns.response(200, "Agent provider updated", console_ns.models[TraceAppConfigResponse.__name__])
@console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.AGENT_EDIT, AgentId())])
def patch(self, context: RequestContext, agent_id: UUID):
payload = TraceConfigPayload.model_validate(console_ns.payload or {})
_tracing_call(
lambda: application_services().agent_tracing_configs.update(
context, str(agent_id), payload.tracing_provider, payload.tracing_config, activate=payload.activate
)
)
return dump_response(TraceAppConfigResponse, {"result": "success"}, exclude_none=True)
@error_responses(
AppNotFoundError, TracingConfigNotFoundError, TracingConfigProcessingError, UnsupportedTracingProviderError
)
@console_ns.doc("delete_agent_trace_config", params=query_params_from_model(TraceProviderQuery))
@console_ns.response(204, "Agent provider configuration deleted")
@console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.AGENT_EDIT, AgentId())])
def delete(self, context: RequestContext, agent_id: UUID):
query = TraceProviderQuery.model_validate(request.args.to_dict(flat=True))
_tracing_call(
lambda: application_services().agent_tracing_configs.delete(context, str(agent_id), query.tracing_provider)
)
return "", 204
def _provider_capabilities():
query = TraceProviderQuery.model_validate(request.args.to_dict(flat=True))
try:
capabilities = application_services().tracing.provider_capabilities.get(query.tracing_provider)
except AppTracingConfigInvalidProviderError as error:
raise UnsupportedTracingProviderError() from error
except AppTracingConfigProviderUnavailableError as error:
raise TracingProviderUnavailableError() from error
return dump_response(
TraceProviderCapabilitiesResponse,
{**asdict(capabilities.support), "api_collection_enabled": capabilities.api_collection_enabled},
)
@console_ns.route("/agent/<uuid:agent_id>/trace-capabilities")
class AgentTraceCapabilitiesApi(Resource):
@error_responses(TracingProviderUnavailableError, UnsupportedTracingProviderError)
@console_ns.doc("get_agent_trace_capabilities", params=query_params_from_model(TraceProviderQuery))
@console_ns.response(
200, "Provider support declarations", console_ns.models[TraceProviderCapabilitiesResponse.__name__]
)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.AGENT_MONITOR, AgentId())])
def get(self, context: RequestContext, agent_id: UUID):
_tracing_call(lambda: application_services().agent_tracing_configs.get_trace(context, str(agent_id)))
return _provider_capabilities()
@console_ns.route("/apps/<uuid:app_id>/trace-capabilities")
class AppTraceCapabilitiesApi(Resource):
@error_responses(TracingProviderUnavailableError, UnsupportedTracingProviderError)
@console_ns.doc("get_app_trace_capabilities", params=query_params_from_model(TraceProviderQuery))
@console_ns.response(
200, "Provider support declarations", console_ns.models[TraceProviderCapabilitiesResponse.__name__]
)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.APP_MONITOR, PlainApp())])
def get(self, context: RequestContext, app_id: UUID):
try:
application_services().apps.console.get_trace(context, str(app_id))
except ConsoleAppNotFoundError as error:
raise NotFound("App not found") from error
return _provider_capabilities()
@@ -0,0 +1,245 @@
"""Authorized trace delivery status and explicit retries of frozen destinations."""
from collections.abc import Callable
from datetime import UTC, datetime
from typing import Literal
from uuid import UUID
from flask import request
from flask_restx import Resource
from pydantic import BaseModel, ConfigDict, Field, TypeAdapter, field_validator
from werkzeug.exceptions import NotFound
from controllers.common.rbac import AgentId, PlainApp, RBACCheck
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
from controllers.console import console_ns
from controllers.console.agent.tracing import TraceProviderSupportResponse
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.base import ResponseModel
from libs.exception import BaseHTTPException
from libs.external_api import error_responses
from libs.helper import dump_response
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.app.agent_app_contracts import AgentAppNotFoundError
from services.tracing.errors import TraceCollectionError
type TraceSourceKind = Literal["message", "workflow", "node"]
_source_kind_adapter = TypeAdapter(TraceSourceKind)
_EDIT_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR})
class TraceRunQuery(BaseModel):
node_execution_id: UUID | None = Field(default=None, description="Select an Agent node invocation within this run")
class TraceRunRetryPayload(BaseModel):
model_config = ConfigDict(extra="forbid")
acknowledge_possible_duplicates: bool = Field(
default=False,
strict=True,
description="Acknowledge possible duplicate records when retrying an uncertain export",
)
class TraceRunStatusResponse(ResponseModel):
status: Literal["not_collected", "collecting", "ready", "exporting", "retrying", "accepted", "failed", "uncertain"]
source_kind: TraceSourceKind
source_id: str
provider: str | None = None
trace_id: str | None = None
trace_url: str | None = None
span_url: str | None = None
project_url: str | None = Field(
default=None,
description="Frozen destination project URL; null when unavailable, never resolved from current config",
)
config_revision: str | None = Field(default=None, description="Frozen destination configuration revision")
capture_content: bool | None = None
capture_agent: bool | None = None
span_count: int | None = None
attempts: int | None = None
error_code: str | None = None
accepted_at: datetime | None = Field(
default=None, description="Ingestion acknowledgement time, not query visibility"
)
queryable: bool | None = Field(default=None, description="Null when third-party query visibility is not verified")
capabilities: TraceProviderSupportResponse | None = None
@field_validator("accepted_at")
@classmethod
def serialize_database_time_as_utc(cls, value: datetime | None) -> datetime | None:
# Database timestamps are naive UTC. Emit a timezone so the generated
# ISO datetime contract and browser parsing agree on the same instant.
if value is None:
return None
return value.replace(tzinfo=UTC) if value.tzinfo is None else value.astimezone(UTC)
class TraceSourceNotFoundError(BaseHTTPException):
error_code = "tracing_source_not_found"
code = 404
description = "The tracing source does not exist in this application."
class TraceNodeNotFoundError(BaseHTTPException):
error_code = "tracing_node_not_found"
code = 404
description = "The Agent node invocation does not belong to this trace."
class TraceRunNotFoundError(BaseHTTPException):
error_code = "tracing_run_not_found"
code = 404
description = "No collected trace is available to retry."
class TraceAlreadyAcceptedError(BaseHTTPException):
error_code = "tracing_already_accepted"
code = 409
description = "An accepted trace cannot be exported again."
class TraceRetryNotAllowedError(BaseHTTPException):
error_code = "tracing_retry_not_allowed"
code = 409
description = "This trace is not in a retryable state."
class TraceDuplicateAcknowledgementRequiredError(BaseHTTPException):
error_code = "tracing_duplicate_acknowledgement_required"
code = 409
description = "Acknowledge possible duplicates before retrying an uncertain export."
_TRACE_ERRORS: dict[str, type[BaseHTTPException]] = {
cls.error_code: cls
for cls in (
TraceSourceNotFoundError,
TraceNodeNotFoundError,
TraceRunNotFoundError,
TraceAlreadyAcceptedError,
TraceRetryNotAllowedError,
TraceDuplicateAcknowledgementRequiredError,
)
}
register_schema_models(console_ns, TraceRunQuery, TraceRunRetryPayload)
register_response_schema_models(console_ns, TraceRunStatusResponse)
def _run_call[T](call: Callable[[], T]) -> T:
try:
return call()
except AgentAppNotFoundError as error:
raise NotFound("Agent not found") from error
except TraceCollectionError as error:
if error_type := _TRACE_ERRORS.get(error.code):
raise error_type() from error
raise
def _query_node_id() -> str | None:
query = TraceRunQuery.model_validate(request.args.to_dict(flat=True))
return str(query.node_execution_id) if query.node_execution_id else None
def _agent_app_id(context: RequestContext, agent_id: UUID) -> str:
return _run_call(lambda: application_services().agent_tracing_configs.resolve_app_id(context, str(agent_id)))
def _status(context: RequestContext, app_id: str, kind: TraceSourceKind, source_id: str):
node_id = _query_node_id()
result = _run_call(
lambda: application_services().tracing.agent_traces.status(
tenant_id=context.active_workspace_id,
app_id=app_id,
source_kind=kind,
source_id=source_id,
node_execution_id=node_id,
)
)
return dump_response(TraceRunStatusResponse, result)
def _retry(context: RequestContext, app_id: str, kind: TraceSourceKind, source_id: str):
node_id = _query_node_id()
payload = TraceRunRetryPayload.model_validate(console_ns.payload or {})
result = _run_call(
lambda: application_services().tracing.agent_traces.retry(
tenant_id=context.active_workspace_id,
app_id=app_id,
source_kind=kind,
source_id=source_id,
node_execution_id=node_id,
acknowledge_possible_duplicates=payload.acknowledge_possible_duplicates,
)
)
return dump_response(TraceRunStatusResponse, result)
@console_ns.route("/agent/<uuid:agent_id>/trace-runs/<uuid:message_id>")
class AgentTraceRunApi(Resource):
@error_responses(TraceSourceNotFoundError, TraceNodeNotFoundError)
@console_ns.doc("get_agent_trace_run", params=query_params_from_model(TraceRunQuery))
@console_ns.response(
200, "Frozen trace destination and export state", console_ns.models[TraceRunStatusResponse.__name__]
)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.AGENT_LOG_MANAGE, AgentId())])
def get(self, context: RequestContext, agent_id: UUID, message_id: UUID):
return _status(context, _agent_app_id(context, agent_id), "message", str(message_id))
@console_ns.route("/agent/<uuid:agent_id>/trace-runs/<uuid:message_id>/retry")
class AgentTraceRunRetryApi(Resource):
@error_responses(*_TRACE_ERRORS.values())
@console_ns.doc("retry_agent_trace_run", params=query_params_from_model(TraceRunQuery))
@console_ns.expect(console_ns.models[TraceRunRetryPayload.__name__])
@console_ns.response(
200, "Retry state for the same frozen destination", console_ns.models[TraceRunStatusResponse.__name__]
)
@console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.AGENT_EDIT, AgentId())])
def post(self, context: RequestContext, agent_id: UUID, message_id: UUID):
return _retry(context, _agent_app_id(context, agent_id), "message", str(message_id))
@console_ns.route("/apps/<uuid:app_id>/trace-runs/<string:source_kind>/<uuid:source_id>")
class AppTraceRunApi(Resource):
@error_responses(TraceSourceNotFoundError, TraceNodeNotFoundError)
@console_ns.doc(
"get_app_trace_run",
params={
**query_params_from_model(TraceRunQuery),
"source_kind": {"enum": ["message", "workflow", "node"]},
},
)
@console_ns.response(
200, "Frozen trace destination and export state", console_ns.models[TraceRunStatusResponse.__name__]
)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.APP_LOG_AND_ANNOTATION, PlainApp())])
def get(self, context: RequestContext, app_id: UUID, source_kind: str, source_id: UUID):
return _status(context, str(app_id), _source_kind_adapter.validate_python(source_kind), str(source_id))
@console_ns.route("/apps/<uuid:app_id>/trace-runs/<string:source_kind>/<uuid:source_id>/retry")
class AppTraceRunRetryApi(Resource):
@error_responses(*_TRACE_ERRORS.values())
@console_ns.doc(
"retry_app_trace_run",
params={
**query_params_from_model(TraceRunQuery),
"source_kind": {"enum": ["message", "workflow", "node"]},
},
)
@console_ns.expect(console_ns.models[TraceRunRetryPayload.__name__])
@console_ns.response(
200, "Retry state for the same frozen destination", console_ns.models[TraceRunStatusResponse.__name__]
)
@console_account_admission(
allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.APP_TRACING_CONFIG, PlainApp())]
)
def post(self, context: RequestContext, app_id: UUID, source_kind: str, source_id: UUID):
return _retry(context, str(app_id), _source_kind_adapter.validate_python(source_kind), str(source_id))