Skip to content

armgit / dify

Public Imported from GitHub
0

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

12.3 KB
Raw Blame
"""Real provider resolution keeps naming metadata and the caller's session isolated."""

import json
from uuid import uuid4

import httpx
import pytest
from dify_trace_sdk.events import ConversationNamed, TraceEvent
from flask import Flask
from sqlalchemy import Connection, event, select
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker

from core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy
from core.errors.error import ProviderTokenNotInitError
from core.llm_generator.prompts import CONVERSATION_TITLE_PROMPT
from core.model_context import get_credit_usage_metadata, use_credit_usage_metadata
from core.plugin.impl import base as plugin_http
from extensions.ext_database import db
from graphon.model_runtime.entities.model_entities import ModelType
from graphon.model_runtime.errors.invoke import InvokeServerUnavailableError
from models import App, AppMode, Tenant
from models.provider import Provider, TenantDefaultModel
from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from services.conversation_name_generator import DefaultModelConversationNameGenerator
from services.tracing.scopes import TraceScopes
from tests.helpers.unit.services.conversation_name_fixtures import _MODEL, _PROVIDER, NamingPlugin
from tests.helpers.unit.services.tracing_ports import untraced_scopes

pytest_plugins = ("tests.helpers.unit.services.conversation_name_fixtures",)


@pytest.mark.parametrize("fail_invoke", [False, True], ids=["success", "provider-error"])
def test_real_provider_invocation_releases_preparation_session_and_preserves_caller(
    naming_app: Flask,
    naming_plugin: NamingPlugin,
    sqlite_session_factory: sessionmaker[Session],
    fail_invoke: bool,
) -> None:
    naming_plugin.fail_invoke = fail_invoke
    tenant = Tenant(name="Naming workspace")
    target = App(
        id=str(uuid4()),
        tenant_id=tenant.id,
        name="Original app",
        mode=AppMode.CHAT,
        enable_site=True,
        enable_api=True,
    )
    with sqlite_session_factory.begin() as session:
        session.add_all(
            [
                tenant,
                target,
                Provider(tenant_id=tenant.id, provider_name=_PROVIDER, is_valid=True),
                TenantDefaultModel(
                    tenant_id=tenant.id, provider_name=_PROVIDER, model_name=_MODEL, model_type=ModelType.LLM
                ),
            ]
        )

    naming_sessions: list[Session] = []
    invocation_metadata: list[dict[str, object]] = []
    preparation_sessions: list[Session] = []

    def observe_transaction(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
        naming_sessions.append(session)

    def observe_request(request: httpx.Request) -> None:
        if request.url.path.endswith("/llm/invoke"):
            preparation_sessions.extend(naming_sessions)
            assert preparation_sessions
            assert all(not session.in_transaction() and not session.identity_map for session in preparation_sessions)
            assert caller_session.get_transaction() is caller_transaction
            assert caller_app is not None
            assert caller_app in caller_session.dirty
            assert caller_app.name == "Pending caller edit"
            invocation_metadata.append(dict(get_credit_usage_metadata() or {}))

    with naming_app.app_context():
        caller_session = db.session()
        caller_app = caller_session.get(App, target.id)
        assert caller_app is not None
        caller_app.name = "Pending caller edit"
        caller_transaction = caller_session.get_transaction()
        original_metadata = get_credit_usage_metadata()
        event.listen(db.session.session_factory, "after_begin", observe_transaction)
        plugin_http._httpx_client.event_hooks["request"].append(observe_request)
        try:
            with use_credit_usage_metadata({"request_id": "name-request", "app_id": target.id}):
                inherited_metadata = dict(get_credit_usage_metadata() or {})
                if fail_invoke:
                    with pytest.raises(InvokeServerUnavailableError, match="Title provider unavailable"):
                        DefaultModelConversationNameGenerator(trace_scopes=untraced_scopes())(
                            tenant_id=tenant.id,
                            app_id=target.id,
                            conversation_id=str(uuid4()),
                            query="First\nquery",
                            app_mode=target.mode,
                        )
                else:
                    name = DefaultModelConversationNameGenerator(trace_scopes=untraced_scopes())(
                        tenant_id=tenant.id,
                        app_id=target.id,
                        conversation_id=str(uuid4()),
                        query="First\nquery",
                        app_mode=target.mode,
                    )
                    assert name == "A generated title"
                assert get_credit_usage_metadata() == inherited_metadata
        finally:
            plugin_http._httpx_client.event_hooks["request"].remove(observe_request)
            event.remove(db.session.session_factory, "after_begin", observe_transaction)

        assert invocation_metadata == [
            {
                **inherited_metadata,
                "app_type": CreditUsageAppType.CHATBOT,
                "created_by": CreditUsageCreatedBy.CONVERSATION_NAME,
            }
        ]
        assert get_credit_usage_metadata() == original_metadata
        assert db.session() is caller_session
        assert caller_session.get_transaction() is caller_transaction
        assert caller_session.in_transaction()
        assert caller_app in caller_session.dirty
        assert caller_app.name == "Pending caller edit"
        assert all(session is not caller_session for session in naming_sessions)
        assert all(not session.in_transaction() and not session.identity_map for session in naming_sessions)
        # Tracing reads its policy through its own store, so preparation is the only scoped session.
        assert naming_sessions == preparation_sessions
        with sqlite_session_factory() as session:
            assert session.scalar(select(App.name).where(App.id == target.id)) == "Original app"

    invocations = [payload for path, payload in naming_plugin.requests if path.endswith("/llm/invoke")]
    assert len(invocations) == 1
    assert invocations[0]["app_id"] == target.id
    assert invocations[0]["data"] == {
        "provider": "naming",
        "model_type": "llm",
        "model": _MODEL,
        "credentials": {},
        "prompt_messages": [{"role": "user", "content": CONVERSATION_TITLE_PROMPT + "First query\n", "name": None}],
        "model_parameters": {"max_tokens": 500, "temperature": 1},
        "tools": None,
        "stop": None,
        "stream": False,
    }


@pytest.mark.parametrize(
    ("app_mode", "app_type"),
    [
        (AppMode.CHAT, CreditUsageAppType.CHATBOT),
        (AppMode.AGENT_CHAT, CreditUsageAppType.AGENT),
        (AppMode.ADVANCED_CHAT, CreditUsageAppType.CHATFLOW),
        (AppMode.AGENT, CreditUsageAppType.AGENT_V2),
    ],
)
def test_provider_resolution_failure_closes_inner_session_and_preserves_caller_context(
    naming_app: Flask,
    sqlite_session_factory: sessionmaker[Session],
    app_mode: AppMode,
    app_type: CreditUsageAppType,
) -> None:
    tenant = Tenant(name="Naming workspace")
    target = App(
        id=str(uuid4()),
        tenant_id=tenant.id,
        name="Original app",
        mode=app_mode,
        enable_site=True,
        enable_api=True,
    )
    with sqlite_session_factory.begin() as session:
        session.add_all([tenant, target])

    provider_sessions: list[Session] = []
    metadata: list[dict[str, object]] = []

    def observe_provider_transaction(
        session: Session, _transaction: SessionTransaction, connection: Connection
    ) -> None:
        # Observe real default-model/provider SQL within the nested app context.
        # A missing default model fails before plugin I/O.
        assert session is db.session()
        assert connection.scalar(select(App.name).where(App.id == target.id)) == "Original app"
        provider_sessions.append(session)
        metadata.append(dict(get_credit_usage_metadata() or {}))

    with naming_app.app_context():
        caller_session = db.session()
        caller_app = caller_session.get(App, target.id)
        assert caller_app is not None
        caller_app.name = "Pending caller edit"
        caller_transaction = caller_session.get_transaction()
        original_metadata = get_credit_usage_metadata()
        event.listen(db.session.session_factory, "after_begin", observe_provider_transaction)
        try:
            with use_credit_usage_metadata({"request_id": "name-request"}):
                inherited_metadata = dict(get_credit_usage_metadata() or {})
                with pytest.raises(ProviderTokenNotInitError, match="^Default model not found for llm$"):
                    DefaultModelConversationNameGenerator(trace_scopes=untraced_scopes())(
                        tenant_id=target.tenant_id,
                        app_id=target.id,
                        conversation_id=str(uuid4()),
                        query="First query",
                        app_mode=app_mode.value,
                    )
                assert get_credit_usage_metadata() == inherited_metadata
        finally:
            event.remove(db.session.session_factory, "after_begin", observe_provider_transaction)
        assert get_credit_usage_metadata() == original_metadata
        assert provider_sessions
        assert all(
            observed
            == {
                **inherited_metadata,
                "app_type": app_type,
                "created_by": CreditUsageCreatedBy.CONVERSATION_NAME,
            }
            for observed in metadata
        )
        assert db.session() is caller_session
        assert caller_session.get_transaction() is caller_transaction
        assert caller_session.in_transaction()
        assert caller_app in caller_session.dirty
        assert caller_app.name == "Pending caller edit"
        for provider_session in provider_sessions:
            assert provider_session is not caller_session
            assert not provider_session.in_transaction()
            assert not provider_session.identity_map
        with sqlite_session_factory() as session:
            stored_app = session.get(App, target.id)
            assert stored_app is not None
            assert stored_app.name == "Original app"


class _TraceRecorder:
    def __init__(self) -> None:
        self.events: list[TraceEvent] = []

    def emit(self, event: TraceEvent) -> None:
        self.events.append(event)


@pytest.mark.usefixtures("naming_plugin")
def test_naming_reports_the_generated_name_to_a_traced_apps_trace(
    naming_app: Flask, sqlite_session_factory: sessionmaker[Session]
) -> None:
    tenant = Tenant(name="Naming workspace")
    target = App(
        id=str(uuid4()),
        tenant_id=tenant.id,
        name="Traced app",
        mode=AppMode.CHAT,
        enable_site=True,
        enable_api=True,
        tracing=json.dumps({"enabled": True, "tracing_provider": "langfuse"}),
    )
    with sqlite_session_factory.begin() as session:
        session.add_all(
            [
                tenant,
                target,
                Provider(tenant_id=tenant.id, provider_name=_PROVIDER, is_valid=True),
                TenantDefaultModel(
                    tenant_id=tenant.id, provider_name=_PROVIDER, model_name=_MODEL, model_type=ModelType.LLM
                ),
            ]
        )
    recorder = _TraceRecorder()
    generator = DefaultModelConversationNameGenerator(
        trace_scopes=TraceScopes(
            emitter=recorder,
            policies=SQLAlchemyAppTracingConfigRepository(session_factory=sqlite_session_factory),
            enterprise_enabled=lambda: False,
        )
    )
    conversation_id = str(uuid4())

    with naming_app.app_context():
        name = generator(
            tenant_id=tenant.id, app_id=target.id, conversation_id=conversation_id, query="First query", app_mode="chat"
        )

    (event,) = recorder.events
    assert (event.tenant_id, event.app_id) == (tenant.id, target.id)
    assert isinstance(event.payload, ConversationNamed)
    assert (event.payload.conversation_id, event.payload.name) == (conversation_id, name)