演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。 Co-authored-by: Cursor <cursoragent@cursor.com>
265 lines
11 KiB
Python
265 lines
11 KiB
Python
"""Generate suggested questions after all conversation query sessions close."""
|
|
|
|
import logging
|
|
from collections.abc import Callable, Generator, Sequence
|
|
from contextlib import contextmanager
|
|
from dataclasses import dataclass
|
|
from functools import partial
|
|
from typing import TYPE_CHECKING, cast
|
|
|
|
from dify_trace_sdk.events import SuggestedQuestionsGenerated
|
|
from flask import current_app
|
|
|
|
from core.app.entities.app_invoke_entities import CreditUsageCreatedBy, get_credit_usage_app_type
|
|
from core.llm_generator.llm_generator import _normalize_completion_params
|
|
from core.model_context import use_credit_usage_metadata, with_credit_usage_created_by
|
|
from core.model_manager import ModelInstance, ModelManager
|
|
from core.plugin.impl.base import use_plugin_daemon_request_timeout
|
|
from core.prompt.utils.prompt_template_parser import PromptTemplateParser
|
|
from extensions.ext_database import db
|
|
from graphon.model_runtime.entities.llm_entities import LLMResult
|
|
from graphon.model_runtime.entities.message_entities import PromptMessage, UserPromptMessage
|
|
from graphon.model_runtime.entities.model_entities import ModelType, ParameterType
|
|
from libs.datetime_utils import measure_time
|
|
from services.message_suggested_questions_parser import SuggestedQuestionsAfterAnswerOutputParser
|
|
from services.tracing.scopes import UNCORRELATED, TraceScopes
|
|
|
|
if TYPE_CHECKING:
|
|
from core.memory.token_buffer_memory import PreparedHistory
|
|
from services.message_suggested_questions_service import SuggestedQuestionsContext
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_SUGGESTED_QUESTIONS_MAX_TOKENS = 256
|
|
_SUGGESTED_QUESTIONS_TIMEOUT_SECONDS = 30.0
|
|
_LOW_REASONING_EFFORTS = ("none", "minimal", "low")
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class PreparedSuggestedQuestionsModel:
|
|
"""Resolved model credentials; ``None`` parameters select the default-model tuning."""
|
|
|
|
model_instance: ModelInstance
|
|
completion_params: dict[str, object] | None
|
|
|
|
|
|
def _default_suggested_questions_model_parameters(model_instance: ModelInstance) -> dict[str, object]:
|
|
"""Build a low-latency parameter set for the workspace default model."""
|
|
parameters: dict[str, object] = {
|
|
"max_tokens": _SUGGESTED_QUESTIONS_MAX_TOKENS,
|
|
"temperature": 0.0,
|
|
}
|
|
|
|
try:
|
|
model_schema = model_instance.get_model_schema()
|
|
except Exception:
|
|
logger.warning("Failed to inspect the default model schema for suggested questions", exc_info=True)
|
|
return parameters
|
|
|
|
parameter_rules = {rule.name: rule for rule in model_schema.parameter_rules}
|
|
thinking_rule = parameter_rules.get("thinking")
|
|
if thinking_rule is not None:
|
|
if thinking_rule.type == ParameterType.BOOLEAN:
|
|
parameters["thinking"] = False
|
|
return parameters
|
|
if "disabled" in thinking_rule.options:
|
|
parameters["thinking"] = "disabled"
|
|
return parameters
|
|
|
|
reasoning_effort_rule = parameter_rules.get("reasoning_effort")
|
|
if reasoning_effort_rule is not None:
|
|
for effort in _LOW_REASONING_EFFORTS:
|
|
if effort in reasoning_effort_rule.options:
|
|
parameters["reasoning_effort"] = effort
|
|
break
|
|
|
|
return parameters
|
|
|
|
|
|
class SuggestedQuestionsGenerator:
|
|
"""Own model resolution, detached-history rendering, generation and tracing."""
|
|
|
|
def __init__(self, *, trace_scopes: TraceScopes) -> None:
|
|
self._trace_scopes = trace_scopes
|
|
|
|
@contextmanager
|
|
def prepare(
|
|
self,
|
|
*,
|
|
context: "SuggestedQuestionsContext",
|
|
instruction_prompt: str | None,
|
|
model_config: object | None,
|
|
) -> Generator[Callable[["PreparedHistory"], list[str]] | None]:
|
|
"""Yield a request-local generator, or None if its history model is unavailable."""
|
|
# Model resolution and tracing may use or commit the scoped session.
|
|
# Isolate them from the caller, retaining one app context across phases.
|
|
with current_app.app_context():
|
|
history_model = self._get_history_model(tenant_id=context.tenant_id)
|
|
db.session.remove()
|
|
if history_model is None:
|
|
yield None
|
|
else:
|
|
yield partial(
|
|
self.generate,
|
|
history_model=history_model,
|
|
context=context,
|
|
instruction_prompt=instruction_prompt,
|
|
model_config=model_config,
|
|
)
|
|
|
|
def generate(
|
|
self,
|
|
history: "PreparedHistory",
|
|
*,
|
|
history_model: ModelInstance,
|
|
context: "SuggestedQuestionsContext",
|
|
instruction_prompt: str | None,
|
|
model_config: object | None,
|
|
) -> list[str]:
|
|
"""Consume detached history within the isolation scope opened by prepare()."""
|
|
histories = history.get_prompt_text(model_instance=history_model, max_token_limit=3000)
|
|
|
|
with (
|
|
measure_time() as timer,
|
|
use_credit_usage_metadata({"app_type": get_credit_usage_app_type(context.app_mode)}),
|
|
):
|
|
model = self._prepare_model(tenant_id=context.tenant_id, model_config=model_config)
|
|
db.session.remove()
|
|
questions: list[str] = (
|
|
list(self._invoke(prepared_model=model, histories=histories, instruction_prompt=instruction_prompt))
|
|
if model is not None
|
|
else []
|
|
)
|
|
|
|
# Invocation catches provider failures, including failed database
|
|
# transactions. Tracing always starts with a fresh scoped session.
|
|
db.session.remove()
|
|
trace_scope = self._trace_scopes.for_app(
|
|
tenant_id=context.tenant_id, app_id=context.app_id, user_id=None, correlation=UNCORRELATED
|
|
)
|
|
if trace_scope is not None:
|
|
trace_scope.emit(
|
|
SuggestedQuestionsGenerated(
|
|
message_id=context.message_id,
|
|
questions=questions,
|
|
started_at=timer.started_at,
|
|
ended_at=timer.ended_at,
|
|
)
|
|
)
|
|
return questions
|
|
|
|
@staticmethod
|
|
def _get_history_model(*, tenant_id: str) -> ModelInstance | None:
|
|
model_manager = ModelManager.for_tenant(tenant_id=tenant_id)
|
|
try:
|
|
return model_manager.get_default_model_instance(tenant_id=tenant_id, model_type=ModelType.LLM)
|
|
except Exception:
|
|
logger.exception("Failed to resolve the history model for suggested questions")
|
|
return None
|
|
|
|
@classmethod
|
|
@with_credit_usage_created_by(CreditUsageCreatedBy.SUGGESTED_QUESTIONS)
|
|
def _prepare_model(
|
|
cls,
|
|
tenant_id: str,
|
|
*,
|
|
model_config: object | None = None,
|
|
) -> PreparedSuggestedQuestionsModel | None:
|
|
"""Resolve the model before its caller releases database sessions.
|
|
|
|
``None`` means no usable configured or default model was found. Schema
|
|
inspection and generation belong to invocation, after the read phase.
|
|
"""
|
|
try:
|
|
model_manager = ModelManager.for_tenant(tenant_id=tenant_id)
|
|
configured_model = cast(dict[str, object], model_config) if isinstance(model_config, dict) else {}
|
|
provider = configured_model.get("provider")
|
|
model_name = configured_model.get("name")
|
|
use_configured_model = False
|
|
|
|
if isinstance(provider, str) and provider and isinstance(model_name, str) and model_name:
|
|
try:
|
|
model_instance = model_manager.get_model_instance(
|
|
tenant_id=tenant_id,
|
|
model_type=ModelType.LLM,
|
|
provider=provider,
|
|
model=model_name,
|
|
)
|
|
use_configured_model = True
|
|
except Exception:
|
|
logger.warning(
|
|
"Failed to use configured suggested-questions model %s/%s, fallback to default model",
|
|
provider,
|
|
model_name,
|
|
exc_info=True,
|
|
)
|
|
model_instance = model_manager.get_default_model_instance(
|
|
tenant_id=tenant_id,
|
|
model_type=ModelType.LLM,
|
|
)
|
|
else:
|
|
model_instance = model_manager.get_default_model_instance(
|
|
tenant_id=tenant_id,
|
|
model_type=ModelType.LLM,
|
|
)
|
|
except Exception:
|
|
logger.exception("Failed to resolve the suggested-questions model")
|
|
return None
|
|
|
|
completion_params: dict[str, object] | None = None
|
|
if use_configured_model:
|
|
configured_completion_params = configured_model.get("completion_params")
|
|
completion_params = (
|
|
dict(configured_completion_params) if isinstance(configured_completion_params, dict) else {}
|
|
)
|
|
return PreparedSuggestedQuestionsModel(
|
|
model_instance=model_instance,
|
|
completion_params=completion_params,
|
|
)
|
|
|
|
@classmethod
|
|
@with_credit_usage_created_by(CreditUsageCreatedBy.SUGGESTED_QUESTIONS)
|
|
def _invoke(
|
|
cls,
|
|
prepared_model: PreparedSuggestedQuestionsModel,
|
|
histories: str,
|
|
*,
|
|
instruction_prompt: str | None = None,
|
|
) -> Sequence[str]:
|
|
"""Generate with an already resolved model without repeating model resolution."""
|
|
output_parser = SuggestedQuestionsAfterAnswerOutputParser(instruction_prompt=instruction_prompt)
|
|
format_instructions = output_parser.get_format_instructions()
|
|
prompt_template = PromptTemplateParser(template="{{histories}}\n{{format_instructions}}\nquestions:\n")
|
|
prompt = prompt_template.format({"histories": histories, "format_instructions": format_instructions})
|
|
|
|
prompt_messages: list[PromptMessage] = [UserPromptMessage(content=prompt)]
|
|
|
|
questions: Sequence[str] = []
|
|
|
|
try:
|
|
model_parameters: dict[str, object]
|
|
stop: list[str]
|
|
model_instance = prepared_model.model_instance
|
|
if prepared_model.completion_params is not None:
|
|
model_parameters, stop = _normalize_completion_params(prepared_model.completion_params)
|
|
else:
|
|
# Default-model generation keeps the built-in suggested-questions tuning.
|
|
model_parameters = _default_suggested_questions_model_parameters(model_instance)
|
|
stop = []
|
|
|
|
with use_plugin_daemon_request_timeout(_SUGGESTED_QUESTIONS_TIMEOUT_SECONDS):
|
|
response: LLMResult = model_instance.invoke_llm(
|
|
prompt_messages=list(prompt_messages),
|
|
model_parameters=model_parameters,
|
|
stop=stop,
|
|
stream=False,
|
|
)
|
|
|
|
text_content = response.message.get_text_content()
|
|
questions = output_parser.parse(text_content) if text_content else []
|
|
except Exception:
|
|
logger.exception("Failed to generate suggested questions after answer")
|
|
questions = []
|
|
|
|
return questions
|