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.

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.py
index 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 defaultdict
from collections.abc import Sequence
+from dataclasses import dataclass
from sqlalchemy import select
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.orm import Session, sessionmaker
from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
from core.app.file_access import DatabaseFileAccessController
@@ -10,7 +11,7 @@ from core.model_manager import ModelInstance
from core.prompt.utils.extract_thread_messages import extract_thread_messages
from extensions.ext_database import db
from factories import file_factory
-from graphon.file import file_manager
+from graphon.file import FileTransferMethod, FileType, FileUploadConfig, file_manager
from 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, MessageFile
from models.workflow import Workflow
from repositories.api_workflow_run_repository import APIWorkflowRunRepository
from 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 = conversation
self.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 files
user_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 files
assistant_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.py
index 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, Sequence
from dataclasses import dataclass
from datetime import UTC, datetime, timedelta
from decimal import Decimal
+from types import SimpleNamespace
from unittest.mock import MagicMock, patch
from uuid import uuid4
import pytest
from sqlalchemy import Engine, event
-from sqlalchemy.orm import Session, scoped_session, sessionmaker
+from sqlalchemy.orm import Session
import models.model as model_module
+from core.app.file_access import FileAccessControllerProtocol
from core.memory import token_buffer_memory as memory_module
from core.memory.token_buffer_memory import TokenBufferMemory
-from graphon.file import FileTransferMethod, FileType
+from graphon.file import File, FileTransferMethod, FileType
from graphon.model_runtime.entities import (
AssistantPromptMessage,
ImagePromptMessageContent,
+ PromptMessage,
PromptMessageRole,
TextPromptMessageContent,
UserPromptMessage,
)
from models.base import TypeBase
from 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, MessageFile
from 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: Session
statements: 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) -> Iterator
statements.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_run
def _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 result
assert "[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]