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.

test: migrate core agent runner sessions and ORM models to SQLite (#40508)

Asuka Minato7128456d571d
diff --git a/api/tests/unit_tests/core/agent/test_base_agent_runner.py b/api/tests/unit_tests/core/agent/test_base_agent_runner.py
index 7411164512c..c6808ed39f6 100644
--- a/api/tests/unit_tests/core/agent/test_base_agent_runner.py
+++ b/api/tests/unit_tests/core/agent/test_base_agent_runner.py
@@ -1,670 +1,693 @@
import json
+from datetime import datetime
from decimal import Decimal
-from unittest.mock import MagicMock
import pytest
from pytest_mock import MockerFixture
+from sqlalchemy.orm import Session
import core.agent.base_agent_runner as module
-import models.model as model_module
from core.agent.base_agent_runner import BaseAgentRunner
-
-# ==========================================================
-# Fixtures
-# ==========================================================
+from core.agent.entities import AgentEntity, AgentToolEntity
+from core.app.app_config.entities import (
+ AppAdditionalFeatures,
+ DatasetEntity,
+ DatasetRetrieveConfigEntity,
+ EasyUIBasedAppModelConfigFrom,
+ ModelConfigEntity,
+ PromptTemplateEntity,
+)
+from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.entities.app_invoke_entities import (
+ AgentChatAppGenerateEntity,
+ InvokeFrom,
+ ModelConfigWithCredentialsEntity,
+)
+from core.model_manager import ModelInstance
+from core.tools.__base.tool import Tool
+from core.tools.__base.tool_runtime import ToolRuntime
+from core.tools.entities.common_entities import I18nObject
+from core.tools.entities.tool_entities import (
+ ToolDescription,
+ ToolEntity,
+ ToolIdentity,
+ ToolProviderType,
+)
+from core.tools.utils.dataset_retriever.dataset_retriever_base_tool import DatasetRetrieverBaseTool
+from core.tools.utils.dataset_retriever_tool import DatasetRetrieverTool
+from extensions.ext_storage import storage
+from extensions.storage.storage_type import StorageType
+from graphon.file import FileTransferMethod, FileType
+from graphon.model_runtime.entities import LLMUsage, PromptMessageTool
+from graphon.model_runtime.model_providers.base.large_language_model import LargeLanguageModel
+from models.enums import ConversationFromSource, CreatorUserRole, MessageFileBelongsTo
+from models.model import AppMode, AppModelConfig, Conversation, Message, MessageAgentThought, MessageFile, UploadFile
+
+
+def _message(
+ *,
+ message_id: str = "msg_current",
+ conversation_id: str = "conv1",
+ query: str = "hello",
+ answer: str = "",
+) -> Message:
+ message = Message(
+ id=message_id,
+ app_id="app1",
+ conversation_id=conversation_id,
+ query=query,
+ message={"role": "user", "content": query},
+ answer=answer,
+ message_unit_price=Decimal(0),
+ answer_unit_price=Decimal(0),
+ currency="USD",
+ from_source=ConversationFromSource.CONSOLE,
+ from_account_id="user",
+ )
+ message._inputs = {}
+ return message
+
+
+def _conversation(*, app_model_config_id: str | None = None) -> Conversation:
+ conversation = Conversation(
+ id="conv1",
+ app_id="app1",
+ app_model_config_id=app_model_config_id,
+ mode=AppMode.AGENT_CHAT,
+ name="Conversation",
+ from_source=ConversationFromSource.CONSOLE,
+ from_account_id="user",
+ is_deleted=False,
+ )
+ conversation._inputs = {}
+ return conversation
+
+
+def _thought(
+ *,
+ thought_id: str,
+ message_id: str = "m1",
+ tool: str | None = None,
+ tool_input: str | None = None,
+ observation: str | None = None,
+ thought: str = "thinking",
+) -> MessageAgentThought:
+ row = MessageAgentThought(
+ message_id=message_id,
+ position=1,
+ created_by_role=CreatorUserRole.ACCOUNT,
+ created_by="user",
+ thought=thought,
+ tool=tool,
+ tool_input=tool_input,
+ observation=observation,
+ tool_labels_str="{}",
+ tool_meta_str="{}",
+ )
+ row.id = thought_id
+ return row
+
+
+def _persist_history(session: Session, *messages: Message, thoughts: list[MessageAgentThought] | None = None) -> None:
+ session.add_all([_conversation(), *messages, *(thoughts or [])])
+ session.commit()
+
+
+def _app_config(
+ *,
+ simple_prompt_template: str | None = "",
+ agent: AgentEntity | None = None,
+ dataset: DatasetEntity | None = None,
+ additional_features: AppAdditionalFeatures | None = None,
+) -> AgentChatAppConfig:
+ return AgentChatAppConfig(
+ tenant_id="tenant",
+ app_id="app1",
+ app_mode=AppMode.AGENT_CHAT,
+ app_model_config_from=EasyUIBasedAppModelConfigFrom.ARGS,
+ app_model_config_dict={},
+ model=ModelConfigEntity(provider="provider", model="model"),
+ prompt_template=PromptTemplateEntity(
+ prompt_type=PromptTemplateEntity.PromptType.SIMPLE,
+ simple_prompt_template=simple_prompt_template,
+ ),
+ agent=agent,
+ dataset=dataset,
+ additional_features=additional_features,
+ )
+
+
+def _app_generate(
+ *,
+ app_config: AgentChatAppConfig | None = None,
+ files: list[str] | None = None,
+) -> AgentChatAppGenerateEntity:
+ """Build the real generate entity with only the fields used by these unit tests."""
+
+ return AgentChatAppGenerateEntity.model_construct(
+ task_id="task",
+ app_config=app_config or _app_config(),
+ inputs={},
+ files=files or [],
+ user_id="user",
+ stream=False,
+ invoke_from=InvokeFrom.DEBUGGER,
+ )
+
+
+def _agent_tool(tool_name: str) -> AgentToolEntity:
+ return AgentToolEntity(
+ provider_type=ToolProviderType.BUILT_IN,
+ provider_id="provider",
+ tool_name=tool_name,
+ )
+
+
+def _agent(*tools: AgentToolEntity) -> AgentEntity:
+ return AgentEntity(
+ provider="provider",
+ model="model",
+ strategy=AgentEntity.Strategy.FUNCTION_CALLING,
+ tools=list(tools),
+ )
+
+
+def _tool_entity(name: str) -> ToolEntity:
+ return ToolEntity(
+ identity=ToolIdentity(
+ author="author",
+ name=name,
+ label=I18nObject(en_US=name),
+ provider="provider",
+ ),
+ description=ToolDescription(
+ human=I18nObject(en_US="Description"),
+ llm="desc",
+ ),
+ )
+
+
+def _dataset_tool(mocker: MockerFixture, name: str) -> DatasetRetrieverTool:
+ return DatasetRetrieverTool(
+ entity=_tool_entity(name),
+ runtime=ToolRuntime(tenant_id="tenant"),
+ retrieval_tool=mocker.Mock(spec=DatasetRetrieverBaseTool),
+ )
@pytest.fixture
-def mock_db_session(mocker: MockerFixture):
- session = mocker.MagicMock()
- mocker.patch.object(module.db, "session", session)
- return session
+def database_session(sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> Session:
+ """Bind legacy global-session writes to a real SQLite Session."""
+
+ monkeypatch.setattr(module.db, "session", sqlite_session)
+ return sqlite_session
@pytest.fixture
-def runner(mocker: MockerFixture):
- r = BaseAgentRunner.__new__(BaseAgentRunner)
- r.tenant_id = "tenant"
- r.user_id = "user"
- r.agent_thought_count = 0
- r.message = mocker.MagicMock(id="msg_current", conversation_id="conv1")
- r.app_config = mocker.MagicMock()
- r.app_config.app_id = "app1"
- r.app_config.agent = None
- r.dataset_tools = []
- r.application_generate_entity = mocker.MagicMock(invoke_from="test")
- r._current_thoughts = []
- return r
-
-
-# ==========================================================
-# _repack_app_generate_entity
-# ==========================================================
+def runner(sqlite_session: Session, mocker: MockerFixture) -> BaseAgentRunner:
+ app_config = _app_config()
+ llm = mocker.Mock(spec=LargeLanguageModel)
+ llm.get_model_schema.return_value = None
+ model_instance = mocker.Mock(
+ spec=ModelInstance,
+ model_type_instance=llm,
+ model_name="model",
+ credentials={},
+ )
+
+ return BaseAgentRunner(
+ session=sqlite_session,
+ tenant_id="tenant",
+ application_generate_entity=_app_generate(app_config=app_config),
+ conversation=_conversation(),
+ app_config=app_config,
+ model_config=ModelConfigWithCredentialsEntity.model_construct(),
+ config=_agent(),
+ queue_manager=mocker.Mock(spec=AppQueueManager),
+ message=_message(),
+ user_id="user",
+ model_instance=model_instance,
+ )
class TestRepack:
- def test_sets_empty_if_none(self, runner: BaseAgentRunner, mocker: MockerFixture):
- entity = mocker.MagicMock()
- entity.app_config.prompt_template.simple_prompt_template = None
+ def test_sets_empty_if_none(self, runner: BaseAgentRunner) -> None:
+ entity = _app_generate(app_config=_app_config(simple_prompt_template=None))
result = runner._repack_app_generate_entity(entity)
assert result.app_config.prompt_template.simple_prompt_template == ""
- def test_keeps_existing(self, runner: BaseAgentRunner, mocker: MockerFixture):
- entity = mocker.MagicMock()
- entity.app_config.prompt_template.simple_prompt_template = "abc"
+ def test_keeps_existing(self, runner: BaseAgentRunner) -> None:
+ entity = _app_generate(app_config=_app_config(simple_prompt_template="abc"))
result = runner._repack_app_generate_entity(entity)
assert result.app_config.prompt_template.simple_prompt_template == "abc"
-# ==========================================================
-# update_prompt_message_tool
-# ==========================================================
-
-
-class TestUpdatePromptTool:
- def test_replaces_prompt_tool_parameters_with_tool_schema(self, runner: BaseAgentRunner, mocker: MockerFixture):
- tool = mocker.MagicMock()
- schema = {
- "type": "object",
- "properties": {"p1": {"type": "string", "description": "desc"}},
- "required": ["p1"],
- }
- tool.get_llm_parameters_json_schema.return_value = schema
-
- prompt_tool = mocker.MagicMock()
- prompt_tool.parameters = {"properties": {}, "required": []}
-
- result = runner.update_prompt_message_tool(tool, prompt_tool)
- assert result.parameters == schema
-
-
-# ==========================================================
-# create_agent_thought
-# ==========================================================
-
-
-class TestCreateAgentThought:
- def test_with_files(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- mock_thought = mocker.MagicMock(id=10)
- mocker.patch.object(module, "MessageAgentThought", return_value=mock_thought)
-
- result = runner.create_agent_thought("m", "msg", "tool", "input", ["f1"])
- assert result == "10"
- assert runner.agent_thought_count == 1
- mock_db_session.add.assert_called_once_with(mock_thought)
- mock_db_session.commit.assert_called_once_with()
- mock_db_session.close.assert_called_once_with()
-
- def test_without_files(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- mock_thought = mocker.MagicMock(id=11)
- mocker.patch.object(module, "MessageAgentThought", return_value=mock_thought)
-
- result = runner.create_agent_thought("m", "msg", "tool", "input", [])
- assert result == "11"
-
-
-# ==========================================================
-# save_agent_thought
-# ==========================================================
-
-
-class TestSaveAgentThought:
- def setup_agent(self, mocker: MockerFixture):
- agent = mocker.MagicMock()
- agent.tool = "tool1;tool2"
- agent.tool_labels = {}
- agent.thought = ""
- return agent
-
- def test_not_found(self, runner: BaseAgentRunner, mock_db_session):
- mock_db_session.scalar.return_value = None
- with pytest.raises(ValueError):
- runner.save_agent_thought("id", None, None, None, None, None, None, [], None)
-
- def test_full_update(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- agent = self.setup_agent(mocker)
- mock_db_session.scalar.return_value = agent
-
- mock_label = mocker.MagicMock()
- mock_label.to_dict.return_value = {"en_US": "label"}
- mocker.patch.object(module.ToolManager, "get_tool_label", return_value=mock_label)
-
- usage = mocker.MagicMock(
- prompt_tokens=1,
- prompt_price_unit=Decimal("0.1"),
- prompt_unit_price=Decimal("0.1"),
- completion_tokens=2,
- completion_price_unit=Decimal("0.2"),
- completion_unit_price=Decimal("0.2"),
- total_tokens=3,
- total_price=Decimal("0.3"),
- )
-
- runner.save_agent_thought(
- "id",
- "tool1;tool2",
- {"a": 1},
- "thought",
- {"b": 2},
- {"meta": 1},
- "answer",
- ["f1"],
- usage,
- )
-
- assert agent.answer == "answer"
- assert agent.tokens == 3
- assert "tool1" in json.loads(agent.tool_labels_str)
- mock_db_session.commit.assert_called_once_with()
- mock_db_session.close.assert_called_once_with()
-
- def test_label_fallback_when_none(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- agent = self.setup_agent(mocker)
- agent.tool = "unknown_tool"
- mock_db_session.scalar.return_value = agent
- mocker.patch.object(module.ToolManager, "get_tool_label", return_value=None)
-
- runner.save_agent_thought("id", None, None, None, None, None, None, [], None)
- labels = json.loads(agent.tool_labels_str)
- assert "unknown_tool" in labels
-
- def test_json_failure_paths(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- agent = self.setup_agent(mocker)
- mock_db_session.scalar.return_value = agent
-
- bad_obj = MagicMock()
- bad_obj.__str__.return_value = "bad"
-
- runner.save_agent_thought(
- "id",
- None,
- bad_obj,
- None,
- bad_obj,
- bad_obj,
- None,
- [],
- None,
- )
-
- assert mock_db_session.commit.called
-
- def test_messages_ids_none(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- agent = self.setup_agent(mocker)
- mock_db_session.scalar.return_value = agent
- runner.save_agent_thought("id", None, None, None, None, None, None, None, None)
- assert mock_db_session.commit.called
-
- def test_success_dict_serialization(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- agent = self.setup_agent(mocker)
- mock_db_session.scalar.return_value = agent
-
- runner.save_agent_thought(
- "id",
- None,
- {"a": 1},
- None,
- {"b": 2},
- None,
- None,
- [],
- None,
- )
-
- assert isinstance(agent.tool_input, str)
- assert isinstance(agent.observation, str)
-
-
-# ==========================================================
-# organize_agent_user_prompt
-# ==========================================================
-
-
-class TestOrganizeUserPrompt:
- def test_no_files(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- caller_session = mocker.MagicMock()
- caller_session.scalars.return_value.all.return_value = []
- msg = mocker.MagicMock(id="1", query="hello", app_model_config=None)
- result = runner.organize_agent_user_prompt(msg, session=caller_session)
- assert result.content == "hello"
- assert mock_db_session.mock_calls == []
-
- def test_with_files_no_config(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- mock_db_session.scalars.return_value.all.return_value = [mocker.MagicMock()]
- msg = mocker.MagicMock(id="1", query="hello", app_model_config=None)
- msg.app_model_config_with_session.return_value = None
- result = runner.organize_agent_user_prompt(msg, session=mock_db_session)
- assert result.content == "hello"
-
- def test_image_detail_low_fallback(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- mock_db_session.scalars.return_value.all.return_value = [mocker.MagicMock()]
- file_config = mocker.MagicMock()
- file_config.image_config = mocker.MagicMock(detail=None)
- mocker.patch.object(module.FileUploadConfigManager, "convert", return_value=file_config)
- mocker.patch.object(module.file_factory, "build_from_message_files", return_value=[])
-
- msg = mocker.MagicMock(id="1", query="hello")
- app_model_config = mocker.MagicMock()
- app_model_config.app_id = "app1"
- app_model_config.to_dict.return_value = {}
- msg.app_model_config_with_session.return_value = app_model_config
- load_annotation_reply_config = mocker.patch.object(
- module, "load_annotation_reply_config", return_value={"enabled": False}
- )
-
- result = runner.organize_agent_user_prompt(msg, session=mock_db_session)
- assert result.content == "hello"
- load_annotation_reply_config.assert_called_once_with(mock_db_session, "app1")
- app_model_config.to_dict.assert_called_once_with(annotation_reply={"enabled": False})
-
-
-# ==========================================================
-# organize_agent_history
-# ==========================================================
-
-
-class TestOrganizeHistory:
- def test_empty(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- caller_session = mocker.MagicMock()
- caller_session.execute.return_value.scalars.return_value.all.return_value = []
- mocker.patch.object(module, "extract_thread_messages", return_value=[])
- result = runner.organize_agent_history([], session=caller_session)
- assert result == []
- assert mock_db_session.mock_calls == []
-
- def test_with_answer_only(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- msg = mocker.MagicMock(id="m1", answer="ans", agent_thoughts=[], app_model_config=None)
- msg.agent_thoughts_with_session.return_value = []
- msg.app_model_config_with_session.return_value = None
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
- result = runner.organize_agent_history([], session=mock_db_session)
- assert any(isinstance(x, module.AssistantPromptMessage) for x in result)
-
- def test_skip_current_message(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- msg = mocker.MagicMock(id="msg_current", agent_thoughts=[], answer="ans", app_model_config=None)
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
- result = runner.organize_agent_history([], session=mock_db_session)
- assert result == []
-
- def test_with_tool_calls_invalid_json(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- thought = mocker.MagicMock(
- tool="tool1",
- tool_input="invalid",
- observation="invalid",
- thought="thinking",
- )
- msg = mocker.MagicMock(id="m2", agent_thoughts=[thought], answer=None, app_model_config=None)
- msg.agent_thoughts_with_session.return_value = [thought]
- msg.app_model_config_with_session.return_value = None
-
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
- mocker.patch("uuid.uuid4", return_value="uuid")
-
- result = runner.organize_agent_history([], session=mock_db_session)
- assert isinstance(result, list)
-
- def test_empty_tool_name_split(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- thought = mocker.MagicMock(tool=";", thought="thinking")
- msg = mocker.MagicMock(id="m5", agent_thoughts=[thought], answer=None, app_model_config=None)
- msg.agent_thoughts_with_session.return_value = [thought]
- msg.app_model_config_with_session.return_value = None
-
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
- result = runner.organize_agent_history([], session=mock_db_session)
- assert isinstance(result, list)
-
- def test_valid_json_tool_flow(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- thought = mocker.MagicMock(
- tool="tool1",
- tool_input=json.dumps({"tool1": {"x": 1}}),
- observation=json.dumps({"tool1": "obs"}),
- thought="thinking",
- )
-
- msg = mocker.MagicMock(
- id="m100",
- agent_thoughts=[thought],
- answer=None,
- app_model_config=None,
- )
- msg.agent_thoughts_with_session.return_value = [thought]
- msg.app_model_config_with_session.return_value = None
-
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
- mocker.patch("uuid.uuid4", return_value="uuid")
-
- result = runner.organize_agent_history([], session=mock_db_session)
- assert isinstance(result, list)
-
-
-# ==========================================================
-# _convert_tool_to_prompt_message_tool (new coverage)
-# ==========================================================
-
-
-class TestConvertToolToPromptMessageTool:
- def test_basic_conversion(self, runner: BaseAgentRunner, mocker: MockerFixture):
- tool = mocker.MagicMock(tool_name="tool1")
-
- tool_entity = mocker.MagicMock()
- tool_entity.entity.description.llm = "desc"
- schema = {
- "type": "object",
- "properties": {"param1": {"type": "string", "description": "desc"}},
- "required": ["param1"],
- }
- tool_entity.get_llm_parameters_json_schema.return_value = schema
-
- mocker.patch.object(module.ToolManager, "get_agent_tool_runtime", return_value=tool_entity)
- mocker.patch.object(module, "PromptMessageTool", side_effect=lambda **kw: MagicMock(**kw))
-
- prompt_tool, entity = runner._convert_tool_to_prompt_message_tool(tool)
- assert entity == tool_entity
- assert prompt_tool.parameters == schema
-
-
-# ==========================================================
-# _init_prompt_tools additional branches
-# ==========================================================
-
-
-class TestInitPromptToolsExtended:
- def test_agent_tool_branch(self, runner: BaseAgentRunner, mocker: MockerFixture):
- agent_tool = mocker.MagicMock(tool_name="agent_tool")
- runner.app_config.agent = mocker.MagicMock(tools=[agent_tool])
- mocker.patch.object(runner, "_convert_tool_to_prompt_message_tool", return_value=(MagicMock(), "entity"))
-
- tools, prompts = runner._init_prompt_tools()
- assert "agent_tool" in tools
-
- def test_exception_in_conversion(self, runner: BaseAgentRunner, mocker: MockerFixture):
- agent_tool = mocker.MagicMock(tool_name="bad_tool")
- runner.app_config.agent = mocker.MagicMock(tools=[agent_tool])
- mocker.patch.object(runner, "_convert_tool_to_prompt_message_tool", side_effect=Exception)
-
- tools, prompts = runner._init_prompt_tools()
- assert tools == {}
-
-
-# ==========================================================
-# Additional Coverage Tests (DO NOT MODIFY EXISTING TESTS)
-# ==========================================================
-
-
-class TestAdditionalCoverage:
- def test_save_agent_thought_existing_labels(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- agent = mocker.MagicMock()
- agent.tool = "tool1"
- agent.tool_labels = {"tool1": {"en_US": "existing"}}
- agent.thought = ""
- mock_db_session.scalar.return_value = agent
-
- runner.save_agent_thought("id", None, None, None, None, None, None, [], None)
- labels = json.loads(agent.tool_labels_str)
- assert labels["tool1"]["en_US"] == "existing"
-
- def test_save_agent_thought_tool_meta_string(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- agent = mocker.MagicMock()
- agent.tool = "tool1"
- agent.tool_labels = {}
- agent.thought = ""
- mock_db_session.scalar.return_value = agent
-
- runner.save_agent_thought("id", None, None, None, None, "meta_string", None, [], None)
- assert agent.tool_meta_str == "meta_string"
-
- def test_convert_dataset_retriever_tool(self, runner: BaseAgentRunner, mocker: MockerFixture):
- ds_tool = mocker.MagicMock()
- ds_tool.entity.identity.name = "ds"
- ds_tool.entity.description.llm = "desc"
-
- param = mocker.MagicMock()
- param.name = "query"
- param.llm_description = "desc"
- param.required = True
-
- ds_tool.get_runtime_parameters.return_value = [param]
-
- mocker.patch.object(module, "PromptMessageTool", side_effect=lambda **kw: MagicMock(**kw))
-
- prompt = runner._convert_dataset_retriever_tool_to_prompt_message_tool(ds_tool)
- assert prompt is not None
-
- def test_organize_user_prompt_with_file_objects(
- self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture
- ):
- mock_db_session.scalars.return_value.all.return_value = [mocker.MagicMock()]
+def test_update_prompt_tool_replaces_parameters(runner: BaseAgentRunner, mocker: MockerFixture) -> None:
+ tool = mocker.Mock(spec=Tool)
+ schema = {
+ "type": "object",
+ "properties": {"p1": {"type": "string", "description": "desc"}},
+ "required": ["p1"],
+ }
+ tool.get_llm_parameters_json_schema.return_value = schema
+ prompt_tool = PromptMessageTool(name="tool", description="", parameters={"properties": {}, "required": []})
+
+ result = runner.update_prompt_message_tool(tool, prompt_tool)
+
+ assert result.parameters == schema
+
+
[email protected](("files", "expected_files"), [(["f1"], '["f1"]'), ([], "")])
+def test_create_agent_thought_persists_row(
+ runner: BaseAgentRunner,
+ database_session: Session,
+ files: list[str],
+ expected_files: str,
+) -> None:
+ thought_id = runner.create_agent_thought("message-1", "message", "tool", "input", files)
+
+ stored = database_session.get(MessageAgentThought, thought_id)
+ assert stored is not None
+ assert stored.message_id == "message-1"
+ assert stored.message_files == expected_files
+ assert stored.position == 1
+ assert runner.agent_thought_count == 1
+
+
+def _persist_thought(session: Session, *, tool: str = "tool1;tool2") -> MessageAgentThought:
+ thought = _thought(thought_id="thought-1", tool=tool, thought="")
+ session.add(thought)
+ session.commit()
+ return thought
+
+
+def test_save_agent_thought_rejects_missing_row(runner: BaseAgentRunner, database_session: Session) -> None:
+ assert database_session.get(MessageAgentThought, "missing") is None
+ with pytest.raises(ValueError, match="agent thought not found"):
+ runner.save_agent_thought("missing", None, None, None, None, None, None, [], None)
+
+
+def test_save_agent_thought_full_update(
+ runner: BaseAgentRunner,
+ database_session: Session,
+ mocker: MockerFixture,
+) -> None:
+ thought = _persist_thought(database_session)
+ label = I18nObject(en_US="label")
+ mocker.patch.object(module.ToolManager, "get_tool_label", return_value=label)
+ usage = LLMUsage(
+ prompt_tokens=1,
+ prompt_price_unit=Decimal("0.1"),
+ prompt_unit_price=Decimal("0.1"),
+ prompt_price=Decimal("0.1"),
+ completion_tokens=2,
+ completion_price_unit=Decimal("0.2"),
+ completion_unit_price=Decimal("0.2"),
+ completion_price=Decimal("0.2"),
+ total_tokens=3,
+ total_price=Decimal("0.3"),
+ currency="USD",
+ latency=0,
+ )
+
+ runner.save_agent_thought(
+ thought.id,
+ "tool1;tool2",
+ {"a": 1},
+ "thought",
+ {"b": 2},
+ {"meta": 1},
+ "answer",
+ ["f1"],
+ usage,
+ )
+
+ stored = database_session.get(MessageAgentThought, thought.id)
+ assert stored is not None
+ assert stored.answer == "answer"
+ assert stored.tokens == 3
+ assert stored.tool_input == '{"a": 1}'
+ assert stored.observation == '{"b": 2}'
+ assert stored.message_files == '["f1"]'
+ assert "tool1" in json.loads(stored.tool_labels_str)
+
+
+def test_save_agent_thought_uses_label_fallback(
+ runner: BaseAgentRunner,
+ database_session: Session,
+ mocker: MockerFixture,
+) -> None:
+ thought = _persist_thought(database_session, tool="unknown_tool")
+ mocker.patch.object(module.ToolManager, "get_tool_label", return_value=None)
+
+ runner.save_agent_thought(thought.id, None, None, None, None, None, None, [], None)
+
+ stored = database_session.get(MessageAgentThought, thought.id)
+ assert stored is not None
+ assert json.loads(stored.tool_labels_str)["unknown_tool"]["en_US"] == "unknown_tool"
+
+
+def test_save_agent_thought_preserves_existing_labels(
+ runner: BaseAgentRunner,
+ database_session: Session,
+) -> None:
+ thought = _persist_thought(database_session, tool="tool1")
+ thought.tool_labels_str = json.dumps({"tool1": {"en_US": "existing"}})
+ database_session.commit()
+
+ runner.save_agent_thought(thought.id, None, None, None, None, None, None, [], None)
+
+ stored = database_session.get(MessageAgentThought, thought.id)
+ assert stored is not None
+ assert json.loads(stored.tool_labels_str)["tool1"]["en_US"] == "existing"
+
+
+def test_save_agent_thought_serialization_fallbacks(
+ runner: BaseAgentRunner,
+ database_session: Session,
+ mocker: MockerFixture,
+) -> None:
+ thought = _persist_thought(database_session, tool="tool1;;")
+ mocker.patch.object(module.ToolManager, "get_tool_label", return_value=None)
+ tool_input = {"a": 1}
+ observation = {"b": 2}
+ tool_meta = {"c": 3}
+ real_dumps = json.dumps
+
+ def dumps_side_effect(value, *args, **kwargs):
+ if value in (tool_input, observation, tool_meta) and kwargs.get("ensure_ascii") is False:
+ raise TypeError("fail")
+ return real_dumps(value, *args, **kwargs)
+
+ mocker.patch.object(module.json, "dumps", side_effect=dumps_side_effect)
+
+ runner.save_agent_thought(
+ thought.id,
+ "tool1;;",
+ tool_input,
+ None,
+ observation,
+ tool_meta,
+ None,
+ [],
+ None,
+ )
+
+ stored = database_session.get(MessageAgentThought, thought.id)
+ assert stored is not None
+ assert isinstance(stored.tool_input, str)
+ assert isinstance(stored.observation, str)
+ assert isinstance(stored.tool_meta_str, str)
+ assert "" not in json.loads(stored.tool_labels_str)
+
+
[email protected]("messages_ids", [None, []])
+def test_save_agent_thought_accepts_empty_message_ids(
+ runner: BaseAgentRunner,
+ database_session: Session,
+ messages_ids: list[str] | None,
+) -> None:
+ thought = _persist_thought(database_session)
+ runner.save_agent_thought(thought.id, None, None, None, None, "meta_string", None, messages_ids, None) # type: ignore[arg-type]
+
+ stored = database_session.get(MessageAgentThought, thought.id)
+ assert stored is not None
+ assert stored.tool_meta_str == "meta_string"
+
+
+def _message_file(
+ *,
+ message_id: str = "m1",
+ belongs_to: MessageFileBelongsTo = MessageFileBelongsTo.ASSISTANT,
+ upload_file_id: str = "upload-1",
+) -> MessageFile:
+ return MessageFile(
+ message_id=message_id,
+ type=FileType.IMAGE,
+ transfer_method=FileTransferMethod.LOCAL_FILE,
+ created_by_role=CreatorUserRole.ACCOUNT,
+ created_by="user",
+ belongs_to=belongs_to,
+ upload_file_id=upload_file_id,
+ )
+
+
+def _file_enabled_app_model_config() -> AppModelConfig:
+ return AppModelConfig(
+ app_id="app1",
+ file_upload=json.dumps(
+ {
+ "enabled": True,
+ "allowed_file_types": [FileType.IMAGE],
+ "allowed_file_extensions": [".png"],
+ "allowed_file_upload_methods": [FileTransferMethod.LOCAL_FILE],
+ "number_limits": 1,
+ "image": {"detail": "low"},
+ }
+ ),
+ )
+
+
+def _upload_file() -> UploadFile:
+ return UploadFile(
+ tenant_id="tenant",
+ storage_type=StorageType.LOCAL,
+ key="image.png",
+ name="image.png",
+ size=1,
+ extension="png",
+ mime_type="image/png",
+ created_by_role=CreatorUserRole.ACCOUNT,
+ created_by="user",
+ created_at=datetime.now(),
+ used=False,
+ )
+
+
+def test_organize_user_prompt_without_files(runner: BaseAgentRunner, sqlite_session: Session) -> None:
+ result = runner.organize_agent_user_prompt(_message(message_id="m1"), session=sqlite_session)
+ assert result.content == "hello"
+
+
+def test_organize_user_prompt_with_files_but_no_config(runner: BaseAgentRunner, sqlite_session: Session) -> None:
+ sqlite_session.add(_message_file())
+ sqlite_session.commit()
+
+ result = runner.organize_agent_user_prompt(_message(message_id="m1"), session=sqlite_session)
+
+ assert result.content == "hello"
+
+
+def test_organize_user_prompt_uses_file_config(
+ runner: BaseAgentRunner,
+ sqlite_session: Session,
+) -> None:
+ config = _file_enabled_app_model_config()
+ sqlite_session.add_all([config, _conversation(app_model_config_id=config.id), _message_file()])
+ sqlite_session.commit()
+
+ result = runner.organize_agent_user_prompt(
+ _message(message_id="m1"),
+ session=sqlite_session,
+ )
+
+ assert result.content == "hello"
+
+
+def test_organize_user_prompt_builds_file_content(
+ runner: BaseAgentRunner,
+ sqlite_session: Session,
+ mocker: MockerFixture,
+) -> None:
+ config = _file_enabled_app_model_config()
+ upload_file = _upload_file()
+ message_file = _message_file(
+ belongs_to=MessageFileBelongsTo.USER,
+ upload_file_id=upload_file.id,
+ )
+ sqlite_session.add_all([config, _conversation(app_model_config_id=config.id), upload_file, message_file])
+ sqlite_session.commit()
+ mocker.patch.object(storage, "load", return_value=b"image")
+
+ result = runner.organize_agent_user_prompt(
+ _message(message_id="m1"),
+ session=sqlite_session,
+ )
+
+ assert isinstance(result.content, list)
+ assert isinstance(result.content[0], module.ImagePromptMessageContent)
+ assert isinstance(result.content[-1], module.TextPromptMessageContent)
+
+
+def test_organize_history_empty_preserves_system_prompt(runner: BaseAgentRunner, sqlite_session: Session) -> None:
+ system_message = module.SystemPromptMessage(content="sys")
+ result = runner.organize_agent_history([system_message], session=sqlite_session)
+ assert result == [system_message]
+
+
+def test_organize_history_with_answer_only(runner: BaseAgentRunner, sqlite_session: Session) -> None:
+ _persist_history(sqlite_session, _message(message_id="m1", answer="answer"))
+ result = runner.organize_agent_history([], session=sqlite_session)
+ assert any(isinstance(item, module.AssistantPromptMessage) and item.content == "answer" for item in result)
+
- file_config = mocker.MagicMock()
- file_config.image_config = mocker.MagicMock(detail=None)
-
- mocker.patch.object(module.FileUploadConfigManager, "convert", return_value=file_config)
- mocker.patch.object(module.file_factory, "build_from_message_files", return_value=["file1"])
- mocker.patch.object(module.file_manager, "to_prompt_message_content", return_value=mocker.MagicMock())
-
- mocker.patch.object(module, "UserPromptMessage", side_effect=lambda **kw: MagicMock(**kw))
- mocker.patch.object(module, "TextPromptMessageContent", side_effect=lambda **kw: MagicMock(**kw))
-
- msg = mocker.MagicMock(id="1", query="hello")
- app_model_config = mocker.MagicMock()
- app_model_config.app_id = "app1"
- app_model_config.to_dict.return_value = {}
- msg.app_model_config_with_session.return_value = app_model_config
- mocker.patch.object(module, "load_annotation_reply_config", return_value={"enabled": False})
-
- result = runner.organize_agent_user_prompt(msg, session=mock_db_session)
- assert result is not None
-
- def test_organize_history_without_tool_names(self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture):
- thought = mocker.MagicMock(tool=None, thought="thinking")
- msg = mocker.MagicMock(id="m3", agent_thoughts=[thought], answer=None, app_model_config=None)
- msg.agent_thoughts_with_session.return_value = [thought]
- msg.app_model_config_with_session.return_value = None
-
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
-
- result = runner.organize_agent_history([], session=mock_db_session)
- assert isinstance(result, list)
-
- def test_organize_history_multiple_tools_split(
- self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture
- ):
- thought = mocker.MagicMock(
- tool="tool1;tool2",
- tool_input=json.dumps({"tool1": {}, "tool2": {}}),
- observation=json.dumps({"tool1": "o1", "tool2": "o2"}),
- thought="thinking",
- )
- msg = mocker.MagicMock(id="m4", agent_thoughts=[thought], answer=None, app_model_config=None)
- msg.agent_thoughts_with_session.return_value = [thought]
- msg.app_model_config_with_session.return_value = None
-
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
- mocker.patch("uuid.uuid4", return_value="uuid")
-
- result = runner.organize_agent_history([], session=mock_db_session)
- assert isinstance(result, list)
-
-
-class TestConvertDatasetRetrieverTool:
- def test_required_param_added(self, runner: BaseAgentRunner, mocker: MockerFixture):
- ds_tool = mocker.MagicMock()
- ds_tool.entity.identity.name = "ds"
- ds_tool.entity.description.llm = "desc"
-
- param = mocker.MagicMock()
- param.name = "query"
- param.llm_description = "desc"
- param.required = True
-
- ds_tool.get_runtime_parameters.return_value = [param]
-
- mocker.patch.object(module, "PromptMessageTool", side_effect=lambda **kw: MagicMock(**kw))
-
- prompt = runner._convert_dataset_retriever_tool_to_prompt_message_tool(ds_tool)
-
- assert prompt is not None
-
-
-class TestBaseAgentRunnerInit:
- def test_init_sets_stream_tool_call_and_files(self, mocker: MockerFixture):
- caller_session = mocker.MagicMock()
- caller_session.scalar.return_value = 2
- global_session = mocker.MagicMock()
- mocker.patch.object(model_module.db, "session", global_session)
- organize_agent_history = mocker.patch.object(BaseAgentRunner, "organize_agent_history", return_value=[])
- get_dataset_tools = mocker.patch.object(
- module.DatasetRetrieverTool, "get_dataset_tools", return_value=["ds_tool"]
- )
-
- llm = mocker.MagicMock()
- llm.get_model_schema.return_value = mocker.MagicMock(
- features=[module.ModelFeature.STREAM_TOOL_CALL, module.ModelFeature.VISION]
- )
- model_instance = mocker.MagicMock(model_type_instance=llm, model="m", credentials="c")
-
- app_config = mocker.MagicMock()
- app_config.app_id = "app1"
- app_config.agent = None
- app_config.dataset = mocker.MagicMock(dataset_ids=["d1"], retrieve_config={"k": "v"})
- app_config.additional_features = mocker.MagicMock(show_retrieve_source=True)
-
- app_generate = mocker.MagicMock(invoke_from="test", inputs={}, files=["file1"])
- message = mocker.MagicMock(id="msg1", conversation_id="conv1")
-
- runner = BaseAgentRunner(
- session=caller_session,
- tenant_id="tenant",
- application_generate_entity=app_generate,
- conversation=mocker.MagicMock(),
- app_config=app_config,
- model_config=mocker.MagicMock(),
- config=mocker.MagicMock(),
- queue_manager=mocker.MagicMock(),
- message=message,
- user_id="user",
- model_instance=model_instance,
- )
-
- assert runner.stream_tool_call is True
- assert runner.files == ["file1"]
- assert runner.dataset_tools == ["ds_tool"]
- assert runner.agent_thought_count == 2
- organize_agent_history.assert_called_once_with(session=caller_session, prompt_messages=[])
- assert get_dataset_tools.call_args.kwargs["session"] is caller_session
- assert global_session.mock_calls == []
-
-
-class TestBaseAgentRunnerCoverage:
- def test_init_prompt_tools_adds_dataset_tools(self, runner: BaseAgentRunner, mocker: MockerFixture):
- dataset_tool = mocker.MagicMock()
- dataset_tool.entity.identity.name = "ds"
- runner.dataset_tools = [dataset_tool]
-
- mocker.patch.object(runner, "_convert_dataset_retriever_tool_to_prompt_message_tool", return_value=MagicMock())
-
- tools, prompt_tools = runner._init_prompt_tools()
-
- assert tools["ds"] == dataset_tool
- assert len(prompt_tools) == 1
-
- def test_save_agent_thought_json_dumps_fallbacks(
- self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture
- ):
- agent = mocker.MagicMock()
- agent.tool = "tool1"
- agent.tool_labels = {}
- agent.thought = ""
- mock_db_session.scalar.return_value = agent
-
- mocker.patch.object(module.ToolManager, "get_tool_label", return_value=None)
-
- tool_input = {"a": 1}
- observation = {"b": 2}
- tool_meta = {"c": 3}
-
- real_dumps = json.dumps
-
- def dumps_side_effect(value, *args, **kwargs):
- if value in (tool_input, observation, tool_meta) and kwargs.get("ensure_ascii") is False:
- raise TypeError("fail")
- return real_dumps(value, *args, **kwargs)
-
- mocker.patch.object(module.json, "dumps", side_effect=dumps_side_effect)
-
- runner.save_agent_thought(
- "id",
- "tool1",
- tool_input,
- None,
- observation,
- tool_meta,
- None,
- [],
- None,
- )
-
- assert isinstance(agent.tool_input, str)
- assert isinstance(agent.observation, str)
- assert isinstance(agent.tool_meta_str, str)
-
- def test_save_agent_thought_skips_empty_tool_name(
- self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture
- ):
- agent = mocker.MagicMock()
- agent.tool = "tool1;;"
- agent.tool_labels = {}
- agent.thought = ""
- mock_db_session.scalar.return_value = agent
-
- mocker.patch.object(module.ToolManager, "get_tool_label", return_value=None)
-
- runner.save_agent_thought("id", None, None, None, None, None, None, [], None)
-
- labels = json.loads(agent.tool_labels_str)
- assert "" not in labels
-
- def test_organize_history_includes_system_prompt(
- self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture
- ):
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = []
- mocker.patch.object(module, "extract_thread_messages", return_value=[])
-
- system_message = module.SystemPromptMessage(content="sys")
-
- result = runner.organize_agent_history([system_message], session=mock_db_session)
-
- assert system_message in result
-
- def test_organize_history_tool_inputs_and_observation_none(
- self, runner: BaseAgentRunner, mock_db_session, mocker: MockerFixture
- ):
- thought = mocker.MagicMock(
- tool="tool1",
- tool_input=None,
- observation=None,
- thought="thinking",
- )
- msg = mocker.MagicMock(id="m6", agent_thoughts=[thought], answer=None, app_model_config=None)
- msg.agent_thoughts_with_session.return_value = [thought]
-
- mock_db_session.execute.return_value.scalars.return_value.all.return_value = [msg]
- mocker.patch.object(module, "extract_thread_messages", return_value=[msg])
- mocker.patch("uuid.uuid4", return_value="uuid")
-
- mocker.patch.object(
- runner,
- "organize_agent_user_prompt",
- return_value=module.UserPromptMessage(content="user"),
- )
-
- result = runner.organize_agent_history([], session=mock_db_session)
-
- assert any(isinstance(item, module.ToolPromptMessage) for item in result)
+def test_organize_history_skips_current_message(runner: BaseAgentRunner, sqlite_session: Session) -> None:
+ _persist_history(sqlite_session, _message(message_id="msg_current", answer="answer"))
+ result = runner.organize_agent_history([], session=sqlite_session)
+ assert result == []
+
+
+ ("tool", "tool_input", "observation"),
+ [
+ ("tool1", "invalid", "invalid"),
+ (";", None, None),
+ ("tool1", None, None),
+ ("tool1;tool2", json.dumps({"tool1": {}, "tool2": {}}), json.dumps({"tool1": "o1", "tool2": "o2"})),
+ ],
+)
+def test_organize_history_reconstructs_tool_flows(
+ runner: BaseAgentRunner,
+ sqlite_session: Session,
+ tool: str,
+ tool_input: str | None,
+ observation: str | None,
+) -> None:
+ message = _message(message_id="m2")
+ thought = _thought(
+ thought_id="thought-1",
+ message_id=message.id,
+ tool=tool,
+ tool_input=tool_input,
+ observation=observation,
+ )
+ _persist_history(sqlite_session, message, thoughts=[thought])
+
+ result = runner.organize_agent_history([], session=sqlite_session)
+
+ assert isinstance(result, list)
+ assert any(isinstance(item, module.AssistantPromptMessage) for item in result)
+
+
+def test_organize_history_without_tool_name(runner: BaseAgentRunner, sqlite_session: Session) -> None:
+ message = _message(message_id="m3")
+ thought = _thought(thought_id="thought-1", message_id=message.id, tool=None)
+ _persist_history(sqlite_session, message, thoughts=[thought])
+
+ result = runner.organize_agent_history([], session=sqlite_session)
+
+ assert any(isinstance(item, module.AssistantPromptMessage) and item.content == "thinking" for item in result)
+
+
+def test_convert_tool_to_prompt_message_tool(runner: BaseAgentRunner, mocker: MockerFixture) -> None:
+ tool = _agent_tool("tool1")
+ tool_entity = mocker.Mock(spec=Tool, entity=_tool_entity("tool1"))
+ schema = {
+ "type": "object",
+ "properties": {"param1": {"type": "string", "description": "desc"}},
+ "required": ["param1"],
+ }
+ tool_entity.get_llm_parameters_json_schema.return_value = schema
+ mocker.patch.object(module.ToolManager, "get_agent_tool_runtime", return_value=tool_entity)
+
+ prompt_tool, entity = runner._convert_tool_to_prompt_message_tool(tool)
+
+ assert entity is tool_entity
+ assert prompt_tool.parameters == schema
+
+
+def test_convert_dataset_retriever_tool(runner: BaseAgentRunner, mocker: MockerFixture) -> None:
+ dataset_tool = _dataset_tool(mocker, "ds")
+
+ prompt = runner._convert_dataset_retriever_tool_to_prompt_message_tool(dataset_tool)
+
+ assert prompt.name == "ds"
+ assert prompt.parameters["required"] == ["query"]
+
+
+def test_init_prompt_tools_adds_agent_and_dataset_tools(runner: BaseAgentRunner, mocker: MockerFixture) -> None:
+ agent_tool = _agent_tool("agent_tool")
+ agent_runtime = mocker.Mock(spec=Tool, entity=_tool_entity("agent_tool"))
+ agent_runtime.get_llm_parameters_json_schema.return_value = {"type": "object", "properties": {}}
+ mocker.patch.object(module.ToolManager, "get_agent_tool_runtime", return_value=agent_runtime)
+ dataset_tool = _dataset_tool(mocker, "dataset_tool")
+ runner.app_config.agent = _agent(agent_tool)
+ runner.dataset_tools = [dataset_tool]
+
+ tools, prompts = runner._init_prompt_tools()
+
+ assert tools == {"agent_tool": agent_runtime, "dataset_tool": dataset_tool}
+ assert len(prompts) == 2
+
+
+def test_init_prompt_tools_skips_deleted_agent_tool(runner: BaseAgentRunner, mocker: MockerFixture) -> None:
+ agent_tool = _agent_tool("bad_tool")
+ runner.app_config.agent = _agent(agent_tool)
+ mocker.patch.object(module.ToolManager, "get_agent_tool_runtime", side_effect=Exception)
+
+ tools, prompts = runner._init_prompt_tools()
+
+ assert tools == {}
+ assert prompts == []
+
+
+def test_init_uses_real_session_for_count_and_dependencies(
+ sqlite_session: Session,
+ mocker: MockerFixture,
+) -> None:
+ sqlite_session.add_all(
+ [
+ _thought(thought_id="thought-1", message_id="msg1"),
+ _thought(thought_id="thought-2", message_id="msg1"),
+ _thought(thought_id="decoy-thought", message_id="other-message"),
+ ]
+ )
+ sqlite_session.commit()
+ get_dataset_tools = mocker.patch.object(
+ module.DatasetRetrieverTool,
+ "get_dataset_tools",
+ return_value=["ds_tool"],
+ )
+ llm = mocker.Mock(spec=LargeLanguageModel)
+ llm.get_model_schema.return_value = mocker.Mock(
+ features=[module.ModelFeature.STREAM_TOOL_CALL, module.ModelFeature.VISION]
+ )
+ model_instance = mocker.Mock(
+ spec=ModelInstance,
+ model_type_instance=llm,
+ model_name="m",
+ credentials="c",
+ )
+ app_config = _app_config(
+ dataset=DatasetEntity(
+ dataset_ids=["d1"],
+ retrieve_config=DatasetRetrieveConfigEntity(
+ retrieve_strategy=DatasetRetrieveConfigEntity.RetrieveStrategy.MULTIPLE,
+ ),
+ ),
+ additional_features=AppAdditionalFeatures(show_retrieve_source=True),
+ )
+ app_generate = _app_generate(app_config=app_config, files=["file1"])
+ message = _message(message_id="msg1")
+
+ initialized = BaseAgentRunner(
+ session=sqlite_session,
+ tenant_id="tenant",
+ application_generate_entity=app_generate,
+ conversation=_conversation(),
+ app_config=app_config,
+ model_config=ModelConfigWithCredentialsEntity.model_construct(),
+ config=_agent(),
+ queue_manager=mocker.Mock(spec=AppQueueManager),
+ message=message,
+ user_id="user",
+ model_instance=model_instance,
+ )
+
+ assert initialized.stream_tool_call is True
+ assert initialized.files == ["file1"]
+ assert initialized.dataset_tools == ["ds_tool"]
+ assert initialized.agent_thought_count == 2
+ assert initialized.history_prompt_messages == []
+ assert get_dataset_tools.call_args.kwargs["session"] is sqlite_session