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): separate history queries from prompt rendering (#42967)
非法操作96f444e3c604
diff --git a/api/core/memory/token_buffer_memory.py b/api/core/memory/token_buffer_memory.pyindex 74b54c17b44..3d0436931cf 100644--- a/api/core/memory/token_buffer_memory.py+++ b/api/core/memory/token_buffer_memory.py@@ -1,8 +1,9 @@from collections import defaultdictfrom collections.abc import Sequence+from dataclasses import dataclassfrom sqlalchemy import select-from sqlalchemy.orm import sessionmaker+from sqlalchemy.orm import Session, sessionmakerfrom core.app.app_config.features.file_upload.manager import FileUploadConfigManagerfrom core.app.file_access import DatabaseFileAccessController@@ -10,7 +11,7 @@ from core.model_manager import ModelInstancefrom core.prompt.utils.extract_thread_messages import extract_thread_messagesfrom extensions.ext_database import dbfrom factories import file_factory-from graphon.file import file_manager+from graphon.file import FileTransferMethod, FileType, FileUploadConfig, file_managerfrom graphon.model_runtime.entities import (AssistantPromptMessage,ImagePromptMessageContent,@@ -20,7 +21,7 @@ from graphon.model_runtime.entities import (UserPromptMessage,)from graphon.model_runtime.entities.message_entities import PromptMessageContentUnionTypes-from models.model import AppMode, Conversation, Message, MessageFile+from models.model import App, AppMode, Conversation, Message, MessageFilefrom models.workflow import Workflowfrom repositories.api_workflow_run_repository import APIWorkflowRunRepositoryfrom repositories.factory import DifyAPIRepositoryFactory@@ -28,114 +29,193 @@ from repositories.factory import DifyAPIRepositoryFactory_file_access_controller = DatabaseFileAccessController()+@dataclass(frozen=True)+class HistoryFile:+ """Persisted attachment reference; metadata and content are resolved after loading history."""++ id: str+ type: FileType+ transfer_method: FileTransferMethod+ url: str | None+ upload_file_id: str | None++ @classmethod+ def from_record(cls, record: MessageFile) -> "HistoryFile":+ return cls(record.id, record.type, record.transfer_method, record.url, record.upload_file_id)+++@dataclass(frozen=True)+class HistoryPrompt:+ text: str+ is_user_message: bool+ files: tuple[HistoryFile, ...]+ tenant_id: str | None+ image_detail: ImagePromptMessageContent.DETAIL++ def to_prompt_message(self) -> PromptMessage:+ contents: list[PromptMessageContentUnionTypes] = []+ if self.files and self.tenant_id is not None:+ for reference in self.files:+ file = file_factory.build_from_mapping(+ mapping={+ "id": reference.id,+ "type": reference.type,+ "transfer_method": reference.transfer_method,+ "url": reference.url,+ "tool_file_id"+ if reference.transfer_method == FileTransferMethod.TOOL_FILE+ else "upload_file_id": reference.upload_file_id,+ },+ tenant_id=self.tenant_id,+ access_controller=_file_access_controller,+ )+ contents.append(file_manager.to_prompt_message_content(file, image_detail_config=self.image_detail))++ if contents:+ contents.append(TextPromptMessageContent(data=self.text))+ content = contents or self.text+ if self.is_user_message:+ return UserPromptMessage(content=content)+ return AssistantPromptMessage(content=content)+++@dataclass(frozen=True)+class PreparedHistory:+ """Detached history that can restore attachments and count tokens without its read session.++ File factories retain ownership of their short metadata lookups. Rendering may+ perform storage/network I/O, so callers should first close the history session.+ """++ prompts: tuple[HistoryPrompt, ...]++ def get_prompt_messages(self, *, model_instance: ModelInstance, max_token_limit: int) -> Sequence[PromptMessage]:+ prompt_messages = [prompt.to_prompt_message() for prompt in self.prompts]+ if not prompt_messages:+ return []++ curr_message_tokens = model_instance.get_llm_num_tokens(prompt_messages)+ while curr_message_tokens > max_token_limit and len(prompt_messages) > 1:+ prompt_messages.pop(0)+ curr_message_tokens = model_instance.get_llm_num_tokens(prompt_messages)+ return prompt_messages++ def get_prompt_text(+ self,+ *,+ model_instance: ModelInstance,+ max_token_limit: int,+ human_prefix: str = "Human",+ ai_prefix: str = "Assistant",+ ) -> str:+ prompt_messages = self.get_prompt_messages(model_instance=model_instance, max_token_limit=max_token_limit)+ return _prompt_messages_to_text(prompt_messages, human_prefix=human_prefix, ai_prefix=ai_prefix)+++def _prompt_messages_to_text(prompt_messages: Sequence[PromptMessage], *, human_prefix: str, ai_prefix: str) -> str:+ string_messages = []+ for message in prompt_messages:+ if message.role == PromptMessageRole.USER:+ role = human_prefix+ elif message.role == PromptMessageRole.ASSISTANT:+ role = ai_prefix+ else:+ continue++ if isinstance(message.content, list):+ inner_msg = ""+ for content in message.content:+ match content:+ case TextPromptMessageContent():+ inner_msg += f"{content.data}\n"+ case ImagePromptMessageContent():+ inner_msg += "[image]\n"+ string_messages.append(f"{role}: {inner_msg.strip()}")+ else:+ string_messages.append(f"{role}: {message.content}")+ return "\n".join(string_messages)++class TokenBufferMemory:def __init__(self,conversation: Conversation,model_instance: ModelInstance,- ):+ ) -> None:self.conversation = conversationself.model_instance = model_instance- self._workflow_run_repo: APIWorkflowRunRepository | None = None- @property- def workflow_run_repo(self) -> APIWorkflowRunRepository:- if self._workflow_run_repo is None:- session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)- self._workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)- return self._workflow_run_repo-- def _build_prompt_message_with_files(- self,- message_files: Sequence[MessageFile],- text_content: str,+ @staticmethod+ def _file_config(+ *,+ conversation: Conversation,+ app_record: App | None,message: Message,- app_record,- is_user_message: bool,- ) -> PromptMessage:- """- Build prompt message with files.- :param message_files: Sequence of MessageFile objects- :param text_content: text content of the message- :param message: Message object- :param app_record: app record- :param is_user_message: whether this is a user message- :return: PromptMessage- """- match self.conversation.mode:+ session: Session,+ workflow_run_repo: APIWorkflowRunRepository | None,+ ) -> FileUploadConfig | None:+ match conversation.mode:case AppMode.AGENT_CHAT | AppMode.COMPLETION | AppMode.CHAT:- file_extra_config = FileUploadConfigManager.convert(- self.conversation.model_config_with_session(session=db.session())- )+ return FileUploadConfigManager.convert(conversation.model_config_with_session(session=session))case AppMode.ADVANCED_CHAT | AppMode.WORKFLOW:- app = self.conversation.app(session=db.session())- if not app:+ if not app_record:raise ValueError("App not found for conversation")-if not message.workflow_run_id:raise ValueError("Workflow run ID not found")-- workflow_run = self.workflow_run_repo.get_workflow_run_by_id(- tenant_id=app.tenant_id, app_id=app.id, run_id=message.workflow_run_id+ assert workflow_run_repo is not None+ workflow_run = workflow_run_repo.get_workflow_run_by_id(+ tenant_id=app_record.tenant_id, app_id=app_record.id, run_id=message.workflow_run_id)if not workflow_run:raise ValueError(f"Workflow run not found: {message.workflow_run_id}")- workflow = db.session.scalar(select(Workflow).where(Workflow.id == workflow_run.workflow_id))+ workflow = session.scalar(select(Workflow).where(Workflow.id == workflow_run.workflow_id))if not workflow:raise ValueError(f"Workflow not found: {workflow_run.workflow_id}")- file_extra_config = FileUploadConfigManager.convert(workflow.features_dict, is_vision=False)+ return FileUploadConfigManager.convert(workflow.features_dict, is_vision=False)case _:- raise AssertionError(f"Invalid app mode: {self.conversation.mode}")+ raise AssertionError(f"Invalid app mode: {conversation.mode}")+ @staticmethod+ def _prepare_prompt(+ *,+ message_files: Sequence[MessageFile],+ text_content: str,+ app_record: App | None,+ is_user_message: bool,+ file_config: FileUploadConfig | None,+ ) -> HistoryPrompt:detail = ImagePromptMessageContent.DETAIL.HIGH- if file_extra_config and app_record:- file_objs = [- file_factory.build_from_message_file(- message_file=message_file,- tenant_id=app_record.tenant_id,- access_controller=_file_access_controller,- )- for message_file in message_files- ]- if file_extra_config.image_config and file_extra_config.image_config.detail:- detail = file_extra_config.image_config.detail- else:- file_objs = []-- if not file_objs:- if is_user_message:- return UserPromptMessage(content=text_content)- else:- return AssistantPromptMessage(content=text_content)- else:- prompt_message_contents: list[PromptMessageContentUnionTypes] = []- for file in file_objs:- prompt_message = file_manager.to_prompt_message_content(- file,- image_detail_config=detail,- )- prompt_message_contents.append(prompt_message)- prompt_message_contents.append(TextPromptMessageContent(data=text_content))-- if is_user_message:- return UserPromptMessage(content=prompt_message_contents)- else:- return AssistantPromptMessage(content=prompt_message_contents)+ files: tuple[HistoryFile, ...] = ()+ if file_config and app_record:+ files = tuple(HistoryFile.from_record(message_file) for message_file in message_files)+ if file_config.image_config and file_config.image_config.detail:+ detail = file_config.image_config.detail+ return HistoryPrompt(+ text=text_content,+ is_user_message=is_user_message,+ files=files,+ tenant_id=app_record.tenant_id if app_record else None,+ image_detail=detail,+ )- def get_history_prompt_messages(- self, max_token_limit: int = 2000, message_limit: int | None = None- ) -> Sequence[PromptMessage]:- """- Get history prompt messages.- :param max_token_limit: max token limit- :param message_limit: message limit+ @classmethod+ def load_history(+ cls,+ *,+ conversation: Conversation,+ app_record: App | None,+ session: Session,+ message_limit: int | None,+ workflow_run_repo: APIWorkflowRunRepository | None = None,+ ) -> PreparedHistory:+ """Read ordered history and attachment configuration without provider or file I/O.++ ``None`` for message_limit uses the existing 500-message ceiling. A missing+ app keeps text-only legacy history available; workflow attachments still+ require the app. An omitted workflow repository uses the configured factory."""- app_record = self.conversation.app(session=db.session())-# fetch limited messages, and return reversed- stmt = (- select(Message).where(Message.conversation_id == self.conversation.id).order_by(Message.created_at.desc())- )+ stmt = select(Message).where(Message.conversation_id == conversation.id).order_by(Message.created_at.desc())if message_limit and message_limit > 0:message_limit = min(message_limit, 500)@@ -144,7 +224,7 @@ class TokenBufferMemory:msg_limit_stmt = stmt.limit(message_limit)- messages = db.session.scalars(msg_limit_stmt).all()+ messages = session.scalars(msg_limit_stmt).all()# instead of all messages from the conversation, we only need to extract messages# that belong to the thread of last message@@ -165,7 +245,7 @@ class TokenBufferMemory:user_files_by_message: dict[str, list[MessageFile]] = defaultdict(list)assistant_files_by_message: dict[str, list[MessageFile]] = defaultdict(list)if message_ids:- for message_file in db.session.scalars(+ for message_file in session.scalars(select(MessageFile).where(MessageFile.message_id.in_(message_ids),(MessageFile.belongs_to == "user") | (MessageFile.belongs_to.is_(None)),@@ -173,7 +253,7 @@ class TokenBufferMemory:).all():user_files_by_message[message_file.message_id].append(message_file)- for message_file in db.session.scalars(+ for message_file in session.scalars(select(MessageFile).where(MessageFile.message_id.in_(message_ids),MessageFile.belongs_to == "assistant",@@ -181,51 +261,56 @@ class TokenBufferMemory:).all():assistant_files_by_message[message_file.message_id].append(message_file)- curr_message_tokens = 0- prompt_messages: list[PromptMessage] = []+ prompts: list[HistoryPrompt] = []for message in messages:- # Process user message with filesuser_files = user_files_by_message.get(message.id, [])-- if user_files:- user_prompt_message = self._build_prompt_message_with_files(- message_files=user_files,- text_content=message.query,- message=message,- app_record=app_record,- is_user_message=True,- )- prompt_messages.append(user_prompt_message)- else:- prompt_messages.append(UserPromptMessage(content=message.query))-- # Process assistant message with filesassistant_files = assistant_files_by_message.get(message.id, [])-- if assistant_files:- assistant_prompt_message = self._build_prompt_message_with_files(- message_files=assistant_files,- text_content=message.answer,- message=message,+ if (+ (user_files or assistant_files)+ and conversation.mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}+ and app_record is not None+ and message.workflow_run_id+ and workflow_run_repo is None+ ):+ session_maker = sessionmaker(bind=session.get_bind(), expire_on_commit=False)+ workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)+ file_config = (+ cls._file_config(+ conversation=conversation,app_record=app_record,- is_user_message=False,+ message=message,+ session=session,+ workflow_run_repo=workflow_run_repo,)- prompt_messages.append(assistant_prompt_message)- else:- prompt_messages.append(AssistantPromptMessage(content=message.answer))-- if not prompt_messages:- return []-- # prune the chat message if it exceeds the max token limit- curr_message_tokens = self.model_instance.get_llm_num_tokens(prompt_messages)-- if curr_message_tokens > max_token_limit:- while curr_message_tokens > max_token_limit and len(prompt_messages) > 1:- prompt_messages.pop(0)- curr_message_tokens = self.model_instance.get_llm_num_tokens(prompt_messages)+ if user_files or assistant_files+ else None+ )+ for files, text_content, is_user_message in (+ (user_files, message.query, True),+ (assistant_files, message.answer, False),+ ):+ prompts.append(+ cls._prepare_prompt(+ message_files=files,+ text_content=text_content,+ app_record=app_record,+ is_user_message=is_user_message,+ file_config=file_config,+ )+ )+ return PreparedHistory(prompts=tuple(prompts))- return prompt_messages+ def get_history_prompt_messages(+ self, max_token_limit: int = 2000, message_limit: int | None = None+ ) -> Sequence[PromptMessage]:+ session = db.session()+ history = self.load_history(+ conversation=self.conversation,+ app_record=self.conversation.app(session=session),+ session=session,+ message_limit=message_limit,+ )+ return history.get_prompt_messages(model_instance=self.model_instance, max_token_limit=max_token_limit)def get_history_prompt_text(self,@@ -244,27 +329,4 @@ class TokenBufferMemory:"""prompt_messages = self.get_history_prompt_messages(max_token_limit=max_token_limit, message_limit=message_limit)- string_messages = []- for m in prompt_messages:- if m.role == PromptMessageRole.USER:- role = human_prefix- elif m.role == PromptMessageRole.ASSISTANT:- role = ai_prefix- else:- continue-- if isinstance(m.content, list):- inner_msg = ""- for content in m.content:- match content:- case TextPromptMessageContent():- inner_msg += f"{content.data}\n"- case ImagePromptMessageContent():- inner_msg += "[image]\n"-- string_messages.append(f"{role}: {inner_msg.strip()}")- else:- message = f"{role}: {m.content}"- string_messages.append(message)-- return "\n".join(string_messages)+ return _prompt_messages_to_text(prompt_messages, human_prefix=human_prefix, ai_prefix=ai_prefix)diff --git a/api/tests/unit_tests/core/memory/test_token_buffer_memory.py b/api/tests/unit_tests/core/memory/test_token_buffer_memory.pyindex 337b2e8efb8..39c4ac7f14b 100644--- a/api/tests/unit_tests/core/memory/test_token_buffer_memory.py+++ b/api/tests/unit_tests/core/memory/test_token_buffer_memory.py@@ -1,30 +1,34 @@"""Comprehensive SQLite-backed tests for token-buffer memory."""-from collections.abc import Iterator+import json+from collections.abc import Iterator, Mapping, Sequencefrom dataclasses import dataclassfrom datetime import UTC, datetime, timedeltafrom decimal import Decimal+from types import SimpleNamespacefrom unittest.mock import MagicMock, patchfrom uuid import uuid4import pytestfrom sqlalchemy import Engine, event-from sqlalchemy.orm import Session, scoped_session, sessionmaker+from sqlalchemy.orm import Sessionimport models.model as model_module+from core.app.file_access import FileAccessControllerProtocolfrom core.memory import token_buffer_memory as memory_modulefrom core.memory.token_buffer_memory import TokenBufferMemory-from graphon.file import FileTransferMethod, FileType+from graphon.file import File, FileTransferMethod, FileTypefrom graphon.model_runtime.entities import (AssistantPromptMessage,ImagePromptMessageContent,+ PromptMessage,PromptMessageRole,TextPromptMessageContent,UserPromptMessage,)from models.base import TypeBasefrom models.enums import ConversationFromSource, CreatorUserRole, MessageFileBelongsTo-from models.model import App, AppMode, Conversation, Message, MessageFile+from models.model import App, AppAnnotationSetting, AppMode, AppModelConfig, Conversation, Message, MessageFilefrom models.workflow import (Workflow,WorkflowExecutionStatus,@@ -43,7 +47,7 @@ class Database:"""Typed SQLite binding plus executed SQL for query-count assertions."""engine: Engine- session: scoped_session[Session]+ session: Sessionstatements: list[tuple[str, object]]@@ -51,7 +55,15 @@ class Database:def database(sqlite_engine: Engine, monkeypatch: pytest.MonkeyPatch) -> Iterator[Database]:TypeBase.metadata.create_all(sqlite_engine,- tables=[App.__table__, Conversation.__table__, Message.__table__, MessageFile.__table__, Workflow.__table__],+ tables=[+ App.__table__,+ Conversation.__table__,+ Message.__table__,+ MessageFile.__table__,+ Workflow.__table__,+ AppModelConfig.__table__,+ AppAnnotationSetting.__table__,+ ],)statements: list[tuple[str, object]] = []@@ -59,15 +71,12 @@ def database(sqlite_engine: Engine, monkeypatch: pytest.MonkeyPatch) -> Iteratorstatements.append((statement, parameters))event.listen(sqlite_engine, "before_cursor_execute", record_statement)- session = scoped_session(sessionmaker(bind=sqlite_engine, expire_on_commit=False))- try:+ with Session(sqlite_engine, expire_on_commit=False) as session:database = Database(engine=sqlite_engine, session=session, statements=statements)- monkeypatch.setattr(memory_module, "db", database)+ monkeypatch.setattr(memory_module, "db", SimpleNamespace(engine=sqlite_engine, session=lambda: session))monkeypatch.setattr(model_module, "db", database)yield database- finally:- session.remove()- event.remove(sqlite_engine, "before_cursor_execute", record_statement)+ event.remove(sqlite_engine, "before_cursor_execute", record_statement)def _make_app(*, app_id: str | None = None, mode: AppMode = AppMode.CHAT) -> App:@@ -110,39 +119,8 @@ def _make_model_instance() -> MagicMock:return mi-def _make_message(answer: str = "hello", answer_tokens: int = 5) -> Message:- return Message(- id=str(uuid4()),- app_id=str(uuid4()),- conversation_id=str(uuid4()),- _inputs={},- query="user query",- message={},- message_unit_price=Decimal(0),- answer=answer,- answer_tokens=answer_tokens,- answer_unit_price=Decimal(0),- currency="USD",- from_source=ConversationFromSource.API,- workflow_run_id=str(uuid4()),- created_at=datetime.now(UTC).replace(tzinfo=None),- )---def _make_message_file() -> MessageFile:- return MessageFile(- message_id=str(uuid4()),- type=FileType.IMAGE,- transfer_method=FileTransferMethod.REMOTE_URL,- created_by_role=CreatorUserRole.ACCOUNT,- created_by=str(uuid4()),- belongs_to=MessageFileBelongsTo.USER,- url="https://example.com/image.png",- )--def _make_workflow_run(*, workflow_id: str | None = None) -> WorkflowRun:- return WorkflowRun(+ workflow_run = WorkflowRun(tenant_id=str(uuid4()),app_id=str(uuid4()),workflow_id=workflow_id or str(uuid4()),@@ -155,6 +133,8 @@ def _make_workflow_run(*, workflow_id: str | None = None) -> WorkflowRun:created_by_role=CreatorUserRole.ACCOUNT,created_by=str(uuid4()),)+ workflow_run.id = str(uuid4())+ return workflow_rundef _persist_message(@@ -224,432 +204,21 @@ def _persist_workflow(database: Database, *, workflow_id: str) -> Workflow:return workflow-# ===========================================================================-# Tests for __init__ and workflow_run_repo property-# ===========================================================================---class TestInit:- def test_init_stores_conversation_and_model_instance(self):- conv = _make_conversation()- mi = _make_model_instance()- mem = TokenBufferMemory(conversation=conv, model_instance=mi)- assert mem.conversation is conv- assert mem.model_instance is mi- assert mem._workflow_run_repo is None-- def test_workflow_run_repo_is_created_lazily(self, database: Database):- conv = _make_conversation()- mi = _make_model_instance()- mem = TokenBufferMemory(conversation=conv, model_instance=mi)-- mock_repo = MagicMock()- with patch(- "core.memory.token_buffer_memory.DifyAPIRepositoryFactory.create_api_workflow_run_repository",- return_value=mock_repo,- ) as repository_factory:- repo = mem.workflow_run_repo- assert repo is mock_repo- assert mem._workflow_run_repo is mock_repo-- session_factory = repository_factory.call_args.args[0]- with session_factory() as session:- assert isinstance(session, Session)- assert session.get_bind() is database.engine-- def test_workflow_run_repo_cached_after_first_access(self):- conv = _make_conversation()- mi = _make_model_instance()- mem = TokenBufferMemory(conversation=conv, model_instance=mi)-- existing_repo = MagicMock()- mem._workflow_run_repo = existing_repo-- with patch(- "core.memory.token_buffer_memory.DifyAPIRepositoryFactory.create_api_workflow_run_repository"- ) as mock_factory:- repo = mem.workflow_run_repo- mock_factory.assert_not_called()- assert repo is existing_repo---# ===========================================================================-# Tests for _build_prompt_message_with_files-# ===========================================================================---class TestBuildPromptMessageWithFiles:- """Tests for the private _build_prompt_message_with_files method."""-- # ------------------------------------------------------------------- # Mode: CHAT / AGENT_CHAT / COMPLETION (simple branch)- # -------------------------------------------------------------------- @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])- def test_chat_mode_no_files_user_message(self, mode):- """When file_extra_config is falsy or app_record is None → plain UserPromptMessage."""- conv = _make_conversation(mode)- mi = _make_model_instance()- mem = TokenBufferMemory(conversation=conv, model_instance=mi)-- with patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=None, # falsy → file_objs = []- ):- result = mem._build_prompt_message_with_files(- message_files=[],- text_content="hello",- message=_make_message(),- app_record=_make_app(),- is_user_message=True,- )-- assert isinstance(result, UserPromptMessage)- assert result.content == "hello"-- @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])- def test_chat_mode_no_files_assistant_message(self, mode):- """Plain AssistantPromptMessage when no files and is_user_message=False."""- conv = _make_conversation(mode)- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- with patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=None,- ):- result = mem._build_prompt_message_with_files(- message_files=[],- text_content="ai reply",- message=_make_message(),- app_record=None,- is_user_message=False,- )-- assert isinstance(result, AssistantPromptMessage)- assert result.content == "ai reply"-- @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])- def test_chat_mode_with_files_user_message(self, mode):- """When files are present, returns UserPromptMessage with list content."""- conv = _make_conversation(mode)- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- mock_file_extra_config = MagicMock()- mock_file_extra_config.image_config = None # no detail override-- mock_file_obj = MagicMock()- # Must be a real entity so Pydantic's tagged union discriminator can validate it- real_image_content = ImagePromptMessageContent(- url="http://example.com/img.png", format="png", mime_type="image/png"- )-- message_file = _make_message_file()- app_record = _make_app()-- with (- patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=mock_file_extra_config,- ),- patch(- "core.memory.token_buffer_memory.file_factory.build_from_message_file",- return_value=mock_file_obj,- ),- patch(- "core.memory.token_buffer_memory.file_manager.to_prompt_message_content",- return_value=real_image_content,- ),- ):- result = mem._build_prompt_message_with_files(- message_files=[message_file],- text_content="user text",- message=_make_message(),- app_record=app_record,- is_user_message=True,- )-- assert isinstance(result, UserPromptMessage)- assert isinstance(result.content, list)- # Last element should be TextPromptMessageContent- assert isinstance(result.content[-1], TextPromptMessageContent)- assert result.content[-1].data == "user text"-- def test_replay_does_not_pass_config_to_file_factory(self):- """Replay contract: history files were validated on upload, so this- path must not forward a FileUploadConfig. The factory's signature- no longer accepts ``config``; this test guards against a future- regression that re-introduces it."""- conv = _make_conversation(AppMode.CHAT)- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- mock_file_extra_config = MagicMock()- mock_file_extra_config.image_config = None-- real_image_content = ImagePromptMessageContent(- url="http://example.com/img.png", format="png", mime_type="image/png"- )- app_record = _make_app()-- with (- patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=mock_file_extra_config,- ),- patch(- "core.memory.token_buffer_memory.file_factory.build_from_message_file",- return_value=MagicMock(),- ) as mock_build,- patch(- "core.memory.token_buffer_memory.file_manager.to_prompt_message_content",- return_value=real_image_content,- ),- ):- mem._build_prompt_message_with_files(- message_files=[_make_message_file()],- text_content="user text",- message=_make_message(),- app_record=app_record,- is_user_message=True,- )-- mock_build.assert_called_once()- assert "config" not in mock_build.call_args.kwargs-- @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])- def test_chat_mode_with_files_assistant_message(self, mode):- """When files are present, returns AssistantPromptMessage with list content."""- conv = _make_conversation(mode)- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- mock_file_extra_config = MagicMock()- mock_file_extra_config.image_config = None-- mock_file_obj = MagicMock()- real_image_content = ImagePromptMessageContent(- url="http://example.com/img.png", format="png", mime_type="image/png"- )- app_record = _make_app()-- with (- patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=mock_file_extra_config,- ),- patch(- "core.memory.token_buffer_memory.file_factory.build_from_message_file",- return_value=mock_file_obj,- ),- patch(- "core.memory.token_buffer_memory.file_manager.to_prompt_message_content",- return_value=real_image_content,- ),- ):- result = mem._build_prompt_message_with_files(- message_files=[_make_message_file()],- text_content="ai text",- message=_make_message(),- app_record=app_record,- is_user_message=False,- )-- assert isinstance(result, AssistantPromptMessage)- assert isinstance(result.content, list)-- @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])- def test_chat_mode_with_files_image_detail_overridden(self, mode):- """When image_config.detail is set, detail is taken from config."""- conv = _make_conversation(mode)- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- mock_image_config = MagicMock()- mock_image_config.detail = ImagePromptMessageContent.DETAIL.LOW-- mock_file_extra_config = MagicMock()- mock_file_extra_config.image_config = mock_image_config-- app_record = _make_app()-- real_image_content = ImagePromptMessageContent(- url="http://example.com/img.png", format="png", mime_type="image/png"- )-- with (- patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=mock_file_extra_config,- ),- patch(- "core.memory.token_buffer_memory.file_factory.build_from_message_file",- return_value=MagicMock(),- ),- patch(- "core.memory.token_buffer_memory.file_manager.to_prompt_message_content",- return_value=real_image_content,- ) as mock_to_prompt,- ):- mem._build_prompt_message_with_files(- message_files=[_make_message_file()],- text_content="user text",- message=_make_message(),- app_record=app_record,- is_user_message=True,- )- # Ensure the LOW detail was passed through- mock_to_prompt.assert_called_once_with(- mock_to_prompt.call_args[0][0], image_detail_config=ImagePromptMessageContent.DETAIL.LOW- )-- @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])- def test_chat_mode_app_record_none_returns_empty_file_objs(self, mode):- """app_record=None path → file_objs stays empty → plain messages."""- conv = _make_conversation(mode)- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- mock_file_extra_config = MagicMock()-- with patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=mock_file_extra_config,- ):- result = mem._build_prompt_message_with_files(- message_files=[_make_message_file()],- text_content="hello",- message=_make_message(),- app_record=None, # <-- forces the else branch → file_objs = []- is_user_message=True,- )-- assert isinstance(result, UserPromptMessage)- assert result.content == "hello"-- # ------------------------------------------------------------------- # Mode: ADVANCED_CHAT / WORKFLOW- # -------------------------------------------------------------------- @pytest.mark.parametrize("mode", [AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])- def test_workflow_mode_no_app_raises(self, mode, database: Database):- """Raises ValueError when the app lookup returns None."""- conv = _make_conversation(mode)- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- with pytest.raises(ValueError, match="App not found for conversation"):- mem._build_prompt_message_with_files(- message_files=[],- text_content="text",- message=_make_message(),- app_record=_make_app(),- is_user_message=True,- )-- @pytest.mark.parametrize("mode", [AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])- def test_workflow_mode_no_workflow_run_id_raises(self, mode, database: Database):- """Raises ValueError when message.workflow_run_id is falsy."""- conv = _persist_conversation(database, mode)-- message = _make_message()- message.workflow_run_id = None # force missing-- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- with pytest.raises(ValueError, match="Workflow run ID not found"):- mem._build_prompt_message_with_files(- message_files=[],- text_content="text",- message=message,- app_record=_make_app(),- is_user_message=True,- )-- @pytest.mark.parametrize("mode", [AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])- def test_workflow_mode_workflow_run_not_found_raises(self, mode, database: Database):- """Raises ValueError when workflow_run_repo returns None."""- conv = _persist_conversation(database, mode)-- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())- mem._workflow_run_repo = MagicMock()- mem._workflow_run_repo.get_workflow_run_by_id.return_value = None-- with pytest.raises(ValueError, match="Workflow run not found"):- mem._build_prompt_message_with_files(- message_files=[],- text_content="text",- message=_make_message(),- app_record=_make_app(),- is_user_message=True,- )-- @pytest.mark.parametrize("mode", [AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])- def test_workflow_mode_workflow_not_found_raises(self, mode, database: Database):- """Raises ValueError when Workflow lookup returns None."""- conv = _persist_conversation(database, mode)- workflow_run = _make_workflow_run()-- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())- mem._workflow_run_repo = MagicMock()- mem._workflow_run_repo.get_workflow_run_by_id.return_value = workflow_run-- with pytest.raises(ValueError, match="Workflow not found"):- mem._build_prompt_message_with_files(- message_files=[],- text_content="text",- message=_make_message(),- app_record=_make_app(),- is_user_message=True,- )-- @pytest.mark.parametrize("mode", [AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])- def test_workflow_mode_success_no_files_user(self, mode, database: Database):- """Happy path: workflow mode, no message files → plain UserPromptMessage."""- conv = _persist_conversation(database, mode)- workflow_run = _make_workflow_run()- workflow = _persist_workflow(database, workflow_id=workflow_run.workflow_id)- app = database.session.get(App, conv.app_id)- assert app is not None- # The repository lookup must see the caller's uncommitted app changes.- app.tenant_id = str(uuid4())- message = _make_message()-- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())- mem._workflow_run_repo = MagicMock()- mem._workflow_run_repo.get_workflow_run_by_id.return_value = workflow_run-- with patch(- "core.memory.token_buffer_memory.FileUploadConfigManager.convert",- return_value=None,- ):- result = mem._build_prompt_message_with_files(- message_files=[],- text_content="wf text",- message=message,- app_record=_make_app(),- is_user_message=True,- )-- assert isinstance(result, UserPromptMessage)- assert result.content == "wf text"- assert database.session.get(Workflow, workflow.id) is workflow- mem._workflow_run_repo.get_workflow_run_by_id.assert_called_once_with(- tenant_id=app.tenant_id, app_id=app.id, run_id=message.workflow_run_id- )-- # ------------------------------------------------------------------- # Invalid mode- # -------------------------------------------------------------------- def test_invalid_mode_raises_assertion(self):- """Any unknown AppMode raises AssertionError."""- conv = _make_conversation()- conv.mode = "unknown_mode" # not in any set- mem = TokenBufferMemory(conversation=conv, model_instance=_make_model_instance())-- with pytest.raises(AssertionError, match="Invalid app mode"):- mem._build_prompt_message_with_files(- message_files=[],- text_content="text",- message=_make_message(),- app_record=_make_app(),- is_user_message=True,- )+def _enable_file_uploads(+ database: Database, conversation: Conversation, *, enabled: bool = True, detail: str = "high"+) -> None:+ conversation.override_model_configs = json.dumps(+ {+ "model": {"provider": "test", "name": "test", "completion_params": {}},+ "file_upload": {+ "enabled": enabled,+ "allowed_file_types": ["image"],+ "allowed_file_upload_methods": ["remote_url", "local_file", "tool_file"],+ "image": {"detail": detail},+ },+ }+ )+ database.session.commit()# ===========================================================================@@ -673,12 +242,36 @@ class TestGetHistoryPromptMessages:message = _persist_message(database, conversation.id, query="My query", answer="My answer")_persist_message_file(database, message, belongs_to=MessageFileBelongsTo.USER)- with patch("core.memory.token_buffer_memory.file_factory.build_from_message_file") as build_file:+ with patch.object(memory_module.file_factory, "build_from_mapping") as build_file:result = mem.get_history_prompt_messages()assert [prompt.content for prompt in result] == ["My query", "My answer"]build_file.assert_not_called()+ @pytest.mark.parametrize("mode", [AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])+ def test_workflow_history_uses_callers_uncommitted_app(self, database: Database, mode: AppMode) -> None:+ mem = self._make_memory(database, mode)+ workflow_run = _make_workflow_run()+ workflow = _persist_workflow(database, workflow_id=workflow_run.workflow_id)+ message = _persist_message(database, mem.conversation.id, workflow_run_id=workflow_run.id)+ _persist_message_file(database, message, belongs_to=MessageFileBelongsTo.USER)+ app = database.session.get(App, mem.conversation.app_id)+ assert app is not None+ app.tenant_id = str(uuid4())+ repository = MagicMock()+ repository.get_workflow_run_by_id.return_value = workflow_run++ with patch.object(+ memory_module.DifyAPIRepositoryFactory, "create_api_workflow_run_repository", return_value=repository+ ):+ result = mem.get_history_prompt_messages()++ assert [prompt.content for prompt in result] == ["user query", "hello"]+ repository.get_workflow_run_by_id.assert_called_once_with(+ tenant_id=app.tenant_id, app_id=app.id, run_id=message.workflow_run_id+ )+ assert database.session.get(Workflow, workflow.id) is workflow+def test_skips_newest_message_without_answer(self, database: Database) -> None:mem = self._make_memory(database)message = _persist_message(database, mem.conversation.id, answer="", answer_tokens=0)@@ -745,20 +338,19 @@ class TestGetHistoryPromptMessages:mem = self._make_memory(database)message = _persist_message(database, mem.conversation.id)message_file = _persist_message_file(database, message, belongs_to=belongs_to)- built_prompt = (- UserPromptMessage(content="built user")- if is_user_message- else AssistantPromptMessage(content="built assistant")- )+ _enable_file_uploads(database, mem.conversation)+ app = database.session.get(App, mem.conversation.app_id)+ assert app is not None- with patch.object(mem, "_build_prompt_message_with_files", return_value=built_prompt) as build_prompt:- result = mem.get_history_prompt_messages()+ history = TokenBufferMemory.load_history(+ conversation=mem.conversation, app_record=app, session=database.session, message_limit=None+ )- build_prompt.assert_called_once()- assert build_prompt.call_args.kwargs["message_files"] == [message_file]- assert build_prompt.call_args.kwargs["is_user_message"] is is_user_message- assert build_prompt.call_args.kwargs["app_record"] is database.session.get(App, mem.conversation.app_id)- assert built_prompt in result+ file_prompt = history.prompts[0 if is_user_message else 1]+ other_prompt = history.prompts[1 if is_user_message else 0]+ assert [reference.id for reference in file_prompt.files] == [message_file.id]+ assert file_prompt.is_user_message is is_user_message+ assert other_prompt.files == ()def test_message_files_are_batch_loaded_with_constant_query_count(self, database: Database) -> None:mem = self._make_memory(database)@@ -940,3 +532,216 @@ class TestGetHistoryPromptText:result = mem.get_history_prompt_text()assert "response text" in resultassert "[image]" in result+++class TestPreparedHistory:+ @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])+ @pytest.mark.parametrize("detail", ["low", "high"])+ def test_load_detaches_history_before_attachment_and_token_io(+ self, database: Database, mode: AppMode, detail: str+ ) -> None:+ conversation = _persist_conversation(database, mode)+ _enable_file_uploads(database, conversation, detail=detail)+ message = _persist_message(database, conversation.id, query="question", answer="answer")+ message_file = _persist_message_file(database, message, belongs_to=MessageFileBelongsTo.USER)+ app = database.session.get(App, conversation.app_id)+ assert app is not None+ file_id, tenant_id = message_file.id, app.tenant_id+ model = _make_model_instance()++ with (+ patch.object(memory_module.file_factory, "build_from_mapping") as build_file,+ patch.object(memory_module.file_manager, "to_prompt_message_content") as to_prompt,+ ):+ history = TokenBufferMemory.load_history(+ conversation=conversation, app_record=app, session=database.session, message_limit=3+ )+ build_file.assert_not_called()+ to_prompt.assert_not_called()+ model.get_llm_num_tokens.assert_not_called()+ message.query = "later query"+ message_file.url = "https://example.com/later.png"+ database.session.close()+ statement_count = len(database.statements)++ def restore_file(+ *, mapping: Mapping[str, object], tenant_id: str, access_controller: FileAccessControllerProtocol+ ) -> File:+ assert not database.session.in_transaction()+ assert mapping["id"] == file_id+ assert mapping["url"] == "https://example.com/image.png"+ assert tenant_id+ assert access_controller is memory_module._file_access_controller+ return File(+ filename="image.png",+ file_type=FileType.IMAGE,+ transfer_method=FileTransferMethod.REMOTE_URL,+ remote_url="https://example.com/image.png",+ mime_type="image/png",+ extension=".png",+ size=42,+ )++ def render_file(+ file: File, *, image_detail_config: ImagePromptMessageContent.DETAIL+ ) -> ImagePromptMessageContent:+ assert not database.session.in_transaction()+ assert image_detail_config == detail+ assert file.remote_url is not None+ return ImagePromptMessageContent(url=file.remote_url, format="png", mime_type="image/png")++ def count_tokens(prompts: Sequence[PromptMessage]) -> int:+ assert prompts+ assert not database.session.in_transaction()+ return 100++ build_file.side_effect = restore_file+ to_prompt.side_effect = render_file+ model.get_llm_num_tokens.side_effect = count_tokens+ text = history.get_prompt_text(model_instance=model, max_token_limit=3000)++ assert text == "Human: [image]\nquestion\nAssistant: answer"+ assert build_file.call_args.kwargs["tenant_id"] == tenant_id+ assert "config" not in build_file.call_args.kwargs+ assert len(database.statements) == statement_count++ @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION])+ def test_disabled_file_uploads_keep_history_text(self, database: Database, mode: AppMode) -> None:+ conversation = _persist_conversation(database, mode)+ _enable_file_uploads(database, conversation, enabled=False)+ message = _persist_message(database, conversation.id)+ _persist_message_file(database, message, belongs_to=MessageFileBelongsTo.USER)+ app = database.session.get(App, conversation.app_id)+ history = TokenBufferMemory.load_history(+ conversation=conversation, app_record=app, session=database.session, message_limit=None+ )+ database.session.close()++ with patch.object(memory_module.file_factory, "build_from_mapping") as build_file:+ text = history.get_prompt_text(model_instance=_make_model_instance(), max_token_limit=3000)++ build_file.assert_not_called()+ assert text == "Human: user query\nAssistant: hello"++ @pytest.mark.parametrize("mode", [AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])+ def test_workflow_attachment_uses_message_run_configuration(self, database: Database, mode: AppMode) -> None:+ conversation = _persist_conversation(database, mode)+ workflow_run = _make_workflow_run()+ workflow = _persist_workflow(database, workflow_id=workflow_run.workflow_id)+ workflow.features = json.dumps({"file_upload": {"enabled": True}})+ message = _persist_message(database, conversation.id, workflow_run_id=workflow_run.id)+ _persist_message_file(database, message, belongs_to=MessageFileBelongsTo.ASSISTANT)+ app = database.session.get(App, conversation.app_id)+ assert app is not None+ repository = MagicMock()+ repository.get_workflow_run_by_id.return_value = workflow_run++ history = TokenBufferMemory.load_history(+ conversation=conversation,+ app_record=app,+ session=database.session,+ message_limit=3,+ workflow_run_repo=repository,+ )++ repository.get_workflow_run_by_id.assert_called_once_with(+ tenant_id=app.tenant_id,+ app_id=app.id,+ run_id=workflow_run.id,+ )+ assert history.prompts[0].files == ()+ assert len(history.prompts[1].files) == 1+ assert history.prompts[1].image_detail == ImagePromptMessageContent.DETAIL.HIGH++ @pytest.mark.parametrize(+ ("missing", "error"),+ [+ ("app", "App not found for conversation"),+ ("run_id", "Workflow run ID not found"),+ ("run", "Workflow run not found"),+ ("workflow", "Workflow not found"),+ ],+ )+ def test_workflow_attachment_missing_context_preserves_error(+ self, database: Database, missing: str, error: str+ ) -> None:+ conversation = _persist_conversation(database, AppMode.ADVANCED_CHAT)+ workflow_run = _make_workflow_run()+ message = _persist_message(+ database, conversation.id, workflow_run_id=None if missing == "run_id" else workflow_run.id+ )+ _persist_message_file(database, message, belongs_to=MessageFileBelongsTo.USER)+ app = None if missing == "app" else database.session.get(App, conversation.app_id)+ repository = MagicMock()+ repository.get_workflow_run_by_id.return_value = None if missing == "run" else workflow_run++ with pytest.raises(ValueError, match=error):+ TokenBufferMemory.load_history(+ conversation=conversation,+ app_record=app,+ session=database.session,+ message_limit=3,+ workflow_run_repo=repository,+ )++ def test_history_preserves_branch_order_and_skips_unfinished_leaf(self, database: Database) -> None:+ conversation = _persist_conversation(database)+ base = datetime.now(UTC).replace(tzinfo=None)+ parent = _persist_message(database, conversation.id, query="parent", created_at=base)+ sibling = _persist_message(database, conversation.id, query="sibling", created_at=base + timedelta(seconds=1))+ sibling.parent_message_id = parent.id+ child = _persist_message(database, conversation.id, query="child", created_at=base + timedelta(seconds=2))+ child.parent_message_id = parent.id+ leaf = _persist_message(+ database,+ conversation.id,+ query="unfinished",+ answer="",+ answer_tokens=0,+ created_at=base + timedelta(seconds=3),+ )+ leaf.parent_message_id = child.id+ database.session.commit()+ app = database.session.get(App, conversation.app_id)+ history = TokenBufferMemory.load_history(+ conversation=conversation,+ app_record=app,+ session=database.session,+ message_limit=4,+ )+ database.session.close()++ assert history.get_prompt_text(model_instance=_make_model_instance(), max_token_limit=3000) == (+ "Human: parent\nAssistant: hello\nHuman: child\nAssistant: hello"+ )++ def test_configured_workflow_repository_is_reused_for_history(self, database: Database) -> None:+ conversation = _persist_conversation(database, AppMode.ADVANCED_CHAT)+ workflow_run = _make_workflow_run()+ workflow = _persist_workflow(database, workflow_id=workflow_run.workflow_id)+ workflow.features = json.dumps({"file_upload": {"enabled": True}})+ parent = _persist_message(database, conversation.id, workflow_run_id=workflow_run.id)+ child = _persist_message(+ database,+ conversation.id,+ workflow_run_id=workflow_run.id,+ created_at=parent.created_at + timedelta(seconds=1),+ )+ child.parent_message_id = parent.id+ for message in (parent, child):+ _persist_message_file(database, message, belongs_to=MessageFileBelongsTo.USER)+ app = database.session.get(App, conversation.app_id)+ repository = MagicMock()+ repository.get_workflow_run_by_id.return_value = workflow_run++ with patch.object(+ memory_module.DifyAPIRepositoryFactory, "create_api_workflow_run_repository", return_value=repository+ ) as create_repository:+ history = TokenBufferMemory.load_history(+ conversation=conversation, app_record=app, session=database.session, message_limit=3+ )++ create_repository.assert_called_once()+ assert repository.get_workflow_run_by_id.call_count == 2+ assert len(history.prompts) == 4+ assert [len(prompt.files) for prompt in history.prompts] == [1, 0, 1, 0]