2308 lines
77 KiB
Python
2308 lines
77 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import json
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
from langchain.agents.middleware.types import ModelRequest, ModelResponse
|
|
from langchain_core.language_models.fake_chat_models import FakeListChatModel
|
|
from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
|
|
|
|
from deerflow.agents.middlewares.clarification_middleware import (
|
|
ClarificationMiddleware,
|
|
)
|
|
from deerflow.agents.middlewares.knowledge_rag_middleware import (
|
|
KnowledgeRagMiddleware,
|
|
)
|
|
from deerflow.agents.middlewares.rag_citation_middleware import (
|
|
RagCitationMiddleware,
|
|
)
|
|
from deerflow.agents.middlewares.smart_reasoning_retrieval_middleware import (
|
|
SMART_REASONING_DUPLICATE_SYNTHESIS_FALLBACK,
|
|
SMART_REASONING_FINAL_SYNTHESIS_PROMPT,
|
|
SMART_REASONING_LIMIT_FALLBACK,
|
|
SMART_REASONING_TOOL_NAMES,
|
|
SMART_RETRIEVAL_HISTORY_MARKER,
|
|
SmartReasoningRetrievalMiddleware,
|
|
sanitize_smart_retrieval_history,
|
|
)
|
|
from deerflow.agents.middlewares.writing_setup_round_cap_middleware import (
|
|
WritingSetupRoundCapMiddleware,
|
|
)
|
|
|
|
|
|
def _request(messages, *, tools=None, runtime=None) -> ModelRequest:
|
|
return ModelRequest(
|
|
model=FakeListChatModel(responses=["unused"]),
|
|
messages=list(messages),
|
|
tools=list(tools or []),
|
|
runtime=runtime,
|
|
)
|
|
|
|
|
|
def _tool_names(request: ModelRequest) -> list[str]:
|
|
names = []
|
|
for tool in request.tools:
|
|
if isinstance(tool, dict):
|
|
names.append(str(tool.get("name") or (tool.get("function") or {}).get("name") or ""))
|
|
else:
|
|
names.append(str(getattr(tool, "name", "") or ""))
|
|
return names
|
|
|
|
|
|
def _assert_tool_protocol_is_valid(messages) -> None:
|
|
pending: set[str] = set()
|
|
for message in messages:
|
|
if isinstance(message, AIMessage):
|
|
assert not pending
|
|
calls = list(message.tool_calls)
|
|
if not calls:
|
|
calls = list((message.additional_kwargs or {}).get("tool_calls") or [])
|
|
pending = {str(call.get("id") or "") for call in calls if call.get("id")}
|
|
elif isinstance(message, ToolMessage):
|
|
assert message.tool_call_id in pending
|
|
pending.remove(message.tool_call_id)
|
|
else:
|
|
assert not pending
|
|
assert not pending
|
|
|
|
|
|
def _raw_baseline(
|
|
user: HumanMessage,
|
|
*,
|
|
query: str | None = None,
|
|
results: list[dict] | None = None,
|
|
):
|
|
raw = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-baseline",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": [query or str(user.content)]},
|
|
}
|
|
],
|
|
)
|
|
raw_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "knowledge_search",
|
|
"results": results or [],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id="raw-baseline",
|
|
name="ordinary_knowledge_search",
|
|
)
|
|
return [user, raw, raw_result]
|
|
|
|
|
|
def test_new_question_drops_old_library_evidence_and_query_but_keeps_current_turn():
|
|
old_ai = AIMessage(
|
|
content="我先核对知识库。",
|
|
tool_calls=[
|
|
{
|
|
"id": "old-smart",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["OLD-QUERY-SECRET"]},
|
|
},
|
|
{
|
|
"id": "old-other",
|
|
"name": "local_calculator",
|
|
"args": {"expression": "1+1"},
|
|
},
|
|
],
|
|
additional_kwargs={
|
|
"tool_calls": [
|
|
{
|
|
"id": "old-smart",
|
|
"type": "function",
|
|
"function": {
|
|
"name": "ordinary_knowledge_search",
|
|
"arguments": '{"queries":["OLD-QUERY-SECRET"]}',
|
|
},
|
|
},
|
|
{
|
|
"id": "old-other",
|
|
"type": "function",
|
|
"function": {
|
|
"name": "local_calculator",
|
|
"arguments": '{"expression":"1+1"}',
|
|
},
|
|
},
|
|
]
|
|
},
|
|
response_metadata={"finish_reason": "tool_calls"},
|
|
)
|
|
old_smart_result = ToolMessage(
|
|
content="OLD-KB-A-EVIDENCE-SECRET",
|
|
tool_call_id="old-smart",
|
|
name="ordinary_knowledge_search",
|
|
additional_kwargs={"mapping_id": "old-library-a"},
|
|
)
|
|
old_other_result = ToolMessage(
|
|
content="calculator-result-2",
|
|
tool_call_id="old-other",
|
|
name="local_calculator",
|
|
)
|
|
current_ai = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "current-smart",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"patterns": ["CURRENT-LIBRARY-B"]},
|
|
}
|
|
],
|
|
)
|
|
current_result = ToolMessage(
|
|
content="CURRENT-KB-B-EVIDENCE",
|
|
tool_call_id="current-smart",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
original = [
|
|
HumanMessage(content="旧问题"),
|
|
old_ai,
|
|
old_smart_result,
|
|
old_other_result,
|
|
AIMessage(content="旧回答"),
|
|
HumanMessage(content="切换到知识库 B 后的新问题"),
|
|
current_ai,
|
|
current_result,
|
|
]
|
|
|
|
captured = {}
|
|
|
|
def handler(request):
|
|
captured["messages"] = request.messages
|
|
return AIMessage(content="新回答")
|
|
|
|
result = SmartReasoningRetrievalMiddleware().wrap_model_call(_request(original), handler)
|
|
|
|
assert isinstance(result, AIMessage)
|
|
sent = captured["messages"]
|
|
rendered = "\n".join(str(message.model_dump()) for message in sent)
|
|
assert "OLD-KB-A-EVIDENCE-SECRET" not in rendered
|
|
assert "OLD-QUERY-SECRET" not in rendered
|
|
assert "old-library-a" not in rendered
|
|
assert SMART_RETRIEVAL_HISTORY_MARKER in rendered
|
|
assert "CURRENT-KB-B-EVIDENCE" in rendered
|
|
assert "CURRENT-LIBRARY-B" in rendered
|
|
|
|
sanitized_old_ai = sent[1]
|
|
assert isinstance(sanitized_old_ai, AIMessage)
|
|
assert [call["name"] for call in sanitized_old_ai.tool_calls] == ["local_calculator"]
|
|
assert sent[2] is old_other_result
|
|
assert sent[-2:] == [current_ai, current_result]
|
|
_assert_tool_protocol_is_valid(sent)
|
|
|
|
# Request rewriting is transient: checkpoint/UI objects retain the full
|
|
# old trace and current evidence.
|
|
assert old_ai.tool_calls[0]["args"]["queries"] == ["OLD-QUERY-SECRET"]
|
|
assert old_smart_result.content == "OLD-KB-A-EVIDENCE-SECRET"
|
|
|
|
|
|
def test_hidden_context_after_question_does_not_make_current_evidence_historical():
|
|
messages = [
|
|
HumanMessage(content="当前问题"),
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "current-read",
|
|
"name": "ordinary_document_chunks",
|
|
"args": {"chunk_id": "safe-current"},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content="当前轮原文证据",
|
|
tool_call_id="current-read",
|
|
name="ordinary_document_chunks",
|
|
),
|
|
HumanMessage(
|
|
content="隐藏业务上下文",
|
|
name="business_context",
|
|
additional_kwargs={"hide_from_ui": True},
|
|
),
|
|
]
|
|
|
|
assert sanitize_smart_retrieval_history(messages) is None
|
|
|
|
|
|
def test_model_selected_retrieval_runs_raw_then_optional_wiki_and_page_read():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "ordinary_document_chunks"},
|
|
]
|
|
user = HumanMessage(content="国内新闻中提到的星河工程进展如何?")
|
|
|
|
first = middleware.wrap_model_call(
|
|
_request([user], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "model-raw",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["星河工程 国内新闻"]},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
|
|
assert isinstance(first, AIMessage)
|
|
assert [call["name"] for call in first.tool_calls] == ["ordinary_knowledge_search"]
|
|
assert first.tool_calls[0]["args"]["queries"] == ["星河工程 国内新闻"]
|
|
raw_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "knowledge_search",
|
|
"result_count": 1,
|
|
"results": [{"title": "星河工程取得阶段性进展"}],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id=first.tool_calls[0]["id"],
|
|
name="ordinary_knowledge_search",
|
|
)
|
|
|
|
wiki_search = middleware.wrap_model_call(
|
|
_request([user, first, raw_result], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="不应和检索同时输出的回答草稿",
|
|
tool_calls=[
|
|
{
|
|
"id": "model-wiki",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "星河工程|阶段性进展"},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
assert isinstance(wiki_search, AIMessage)
|
|
assert wiki_search.content == ""
|
|
assert [call["name"] for call in wiki_search.tool_calls] == ["ordinary_wiki_search"]
|
|
assert "星河工程" in wiki_search.tool_calls[0]["args"]["pattern"]
|
|
wiki_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "wiki_search",
|
|
"result_count": 1,
|
|
"results": [{"page_ref": "wkpage-star-river"}],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id=wiki_search.tool_calls[0]["id"],
|
|
name="ordinary_wiki_search",
|
|
)
|
|
|
|
wiki_read = middleware.wrap_model_call(
|
|
_request([user, first, raw_result, wiki_search, wiki_result], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "model-wiki-read",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-star-river"},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
assert isinstance(wiki_read, AIMessage)
|
|
assert wiki_read.content == ""
|
|
assert [call["name"] for call in wiki_read.tool_calls] == ["ordinary_wiki_read_page"]
|
|
assert wiki_read.tool_calls[0]["args"] == {"page_ref": "wkpage-star-river"}
|
|
wiki_page = ToolMessage(
|
|
content='{"ok":true,"operation":"wiki_read_page","result_count":1,"results":[]}',
|
|
tool_call_id=wiki_read.tool_calls[0]["id"],
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
|
|
final = middleware.wrap_model_call(
|
|
_request(
|
|
[
|
|
user,
|
|
first,
|
|
raw_result,
|
|
wiki_search,
|
|
wiki_result,
|
|
wiki_read,
|
|
wiki_page,
|
|
],
|
|
tools=tools,
|
|
),
|
|
lambda _request: AIMessage(content="已综合回答"),
|
|
)
|
|
assert isinstance(final, AIMessage)
|
|
assert final.content == "已综合回答"
|
|
assert final.tool_calls == []
|
|
|
|
|
|
def test_skill_only_actions_remain_available_without_forced_retrieval():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "skill_view"},
|
|
{"name": "skill_list"},
|
|
{"name": "local_calculator"},
|
|
]
|
|
user = HumanMessage(content="读取库内项目数据并计算同比")
|
|
|
|
first = middleware.wrap_model_call(
|
|
_request([user], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "skill-alongside-raw",
|
|
"name": "skill_view",
|
|
"args": {"name": "data-analysis"},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
assert [call["name"] for call in first.tool_calls] == ["skill_view"]
|
|
|
|
|
|
def test_retrieval_and_skill_calls_are_serialized_before_tool_execution():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[HumanMessage(content="读取库内项目数据并计算同比")],
|
|
tools=[
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "skill_view"},
|
|
{"name": "local_calculator"},
|
|
],
|
|
),
|
|
lambda _request: AIMessage(
|
|
content="报告草稿不应提前出现",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-first",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["项目同比数据"]},
|
|
},
|
|
{
|
|
"id": "skill-later",
|
|
"name": "skill_view",
|
|
"args": {"name": "data-analysis"},
|
|
},
|
|
{
|
|
"id": "calculator-later",
|
|
"name": "local_calculator",
|
|
"args": {"expression": "120/100-1"},
|
|
},
|
|
],
|
|
),
|
|
)
|
|
|
|
assert result.content == ""
|
|
assert [call["name"] for call in result.tool_calls] == [
|
|
"ordinary_knowledge_search"
|
|
]
|
|
assert result.additional_kwargs["knowledge_retrieval_output_actions_deferred"] == 2
|
|
|
|
|
|
def test_skill_discovery_and_read_only_file_access_do_not_force_retrieval():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[HumanMessage(content="根据所选库和本地资料分析项目")],
|
|
tools=[
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "search_skills"},
|
|
{"name": "read_file"},
|
|
],
|
|
),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "discover-analysis-skill",
|
|
"name": "search_skills",
|
|
"args": {"query": "数据分析"},
|
|
},
|
|
{
|
|
"id": "read-user-material",
|
|
"name": "read_file",
|
|
"args": {"file_path": "/mnt/user-data/uploads/补充材料.txt"},
|
|
},
|
|
],
|
|
),
|
|
)
|
|
|
|
assert [call["name"] for call in result.tool_calls] == [
|
|
"search_skills",
|
|
"read_file",
|
|
]
|
|
|
|
|
|
def test_retrieval_defers_all_parallel_actions_until_model_reads_result():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "skill_view"},
|
|
{"name": "bash"},
|
|
{"name": "write_file"},
|
|
{"name": "str_replace"},
|
|
{"name": "present_files"},
|
|
]
|
|
user = HumanMessage(content="根据知识库写一份治理报告")
|
|
raw_history = _raw_baseline(user, query="治理报告")
|
|
|
|
wiki = middleware.wrap_model_call(
|
|
_request(raw_history, tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="报告正文已经写完",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "治理|报告"},
|
|
},
|
|
{
|
|
"id": "write-too-early",
|
|
"name": "write_file",
|
|
"args": {"path": "/mnt/user-data/outputs/report.md", "content": "完整报告"},
|
|
},
|
|
{
|
|
"id": "replace-too-early",
|
|
"name": "str_replace",
|
|
"args": {
|
|
"path": "/mnt/user-data/outputs/report.md",
|
|
"old_str": "旧结论",
|
|
"new_str": "未核验的新结论",
|
|
},
|
|
},
|
|
{
|
|
"id": "bash-too-early",
|
|
"name": "bash",
|
|
"args": {"command": "python /mnt/skills/report/run.py > /mnt/user-data/outputs/report.md"},
|
|
},
|
|
{
|
|
"id": "skill-is-read-only",
|
|
"name": "skill_view",
|
|
"args": {"name": "report-writing"},
|
|
},
|
|
],
|
|
),
|
|
)
|
|
|
|
assert [call["name"] for call in wiki.tool_calls] == ["ordinary_wiki_search"]
|
|
assert wiki.content == ""
|
|
assert wiki.additional_kwargs["knowledge_retrieval_output_actions_deferred"] == 4
|
|
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[{"page_ref":"wkpage-report"}]}',
|
|
tool_call_id="wiki-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
page_read = middleware.wrap_model_call(
|
|
_request([*raw_history, wiki, wiki_result], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="仍不能提前展示报告",
|
|
tool_calls=[
|
|
{
|
|
"id": "read-report-wiki",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-report"},
|
|
},
|
|
{
|
|
"id": "present-too-early",
|
|
"name": "present_files",
|
|
"args": {"filepaths": ["/mnt/user-data/outputs/report.md"]},
|
|
},
|
|
],
|
|
),
|
|
)
|
|
assert [call["name"] for call in page_read.tool_calls] == ["ordinary_wiki_read_page"]
|
|
assert page_read.additional_kwargs["knowledge_retrieval_output_actions_deferred"] == 1
|
|
assert page_read.content == ""
|
|
|
|
page_result = ToolMessage(
|
|
content='{"ok":true,"results":[{"complete":true,"content":"已核验事实"}]}',
|
|
tool_call_id=page_read.tool_calls[0]["id"],
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
completed = middleware.wrap_model_call(
|
|
_request(
|
|
[
|
|
*raw_history,
|
|
wiki,
|
|
wiki_result,
|
|
page_read,
|
|
page_result,
|
|
],
|
|
tools=tools,
|
|
),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "write-after-evidence",
|
|
"name": "write_file",
|
|
"args": {
|
|
"path": "/mnt/user-data/outputs/report.md",
|
|
"content": "基于完整证据的报告",
|
|
},
|
|
},
|
|
{
|
|
"id": "bash-after-evidence",
|
|
"name": "bash",
|
|
"args": {"command": "python /mnt/skills/report/check.py"},
|
|
},
|
|
],
|
|
),
|
|
)
|
|
assert [call["name"] for call in completed.tool_calls] == ["write_file", "bash"]
|
|
assert "knowledge_retrieval_output_actions_deferred" not in completed.additional_kwargs
|
|
|
|
|
|
def test_wiki_aliases_and_links_guide_but_do_not_fix_adaptive_expansion_query():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="核对星河工程的承建单位")
|
|
raw_history = _raw_baseline(user, query="星河工程 承建单位")
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "adaptive-wiki-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "星河工程|承建单位"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[{"page_ref":"wkpage-adaptive"}]}',
|
|
tool_call_id="adaptive-wiki-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
wiki_read = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "adaptive-wiki-read",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-adaptive"},
|
|
}
|
|
],
|
|
)
|
|
wiki_page = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"results": [
|
|
{
|
|
"title": "星河工程建设进展",
|
|
# Providers may return one alias/link without wrapping
|
|
# it in a list; it must remain one complete term.
|
|
"aliases": "星河计划",
|
|
"links": {"title": "天衡建设集团"},
|
|
"complete": True,
|
|
}
|
|
],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id="adaptive-wiki-read",
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
captured: dict[str, ModelRequest] = {}
|
|
|
|
def handler(request: ModelRequest) -> AIMessage:
|
|
captured["request"] = request
|
|
return AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "adaptive-expanded-raw",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["天衡建设集团 星河计划 承建合同"]},
|
|
}
|
|
],
|
|
)
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[
|
|
*raw_history,
|
|
wiki_search,
|
|
wiki_result,
|
|
wiki_read,
|
|
wiki_page,
|
|
],
|
|
tools=tools,
|
|
),
|
|
handler,
|
|
)
|
|
|
|
guidance = str(captured["request"].messages[-1].content)
|
|
assert "候选扩展词" in guidance
|
|
assert "星河计划" in guidance
|
|
assert "天衡建设集团" in guidance
|
|
assert "删减、组合或改写" in guidance
|
|
assert result.tool_calls[0]["args"]["queries"] == ["天衡建设集团 星河计划 承建合同"]
|
|
|
|
|
|
def test_direct_answer_passes_through_without_forced_retrieval():
|
|
result = SmartReasoningRetrievalMiddleware().wrap_model_call(
|
|
_request(
|
|
[HumanMessage(content="介绍国内人工智能产业新闻")],
|
|
tools=[
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
],
|
|
),
|
|
lambda _request: AIMessage(content="无需库内专属事实,可以直接回答"),
|
|
)
|
|
|
|
assert isinstance(result, AIMessage)
|
|
assert result.content == "无需库内专属事实,可以直接回答"
|
|
assert result.tool_calls == []
|
|
|
|
|
|
def test_first_model_selected_retrieval_is_rewritten_to_raw_search():
|
|
result = SmartReasoningRetrievalMiddleware().wrap_model_call(
|
|
_request(
|
|
[HumanMessage(content="梳理库内新闻时间线")],
|
|
tools=[
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
],
|
|
),
|
|
lambda _request: AIMessage(
|
|
content="不应提前出现的总结",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-before-raw",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "新闻|时间线"},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
|
|
assert result.content == ""
|
|
assert [call["name"] for call in result.tool_calls] == [
|
|
"ordinary_knowledge_search"
|
|
]
|
|
assert result.tool_calls[0]["args"]["queries"] == ["梳理库内新闻时间线"]
|
|
|
|
|
|
def test_failed_raw_baseline_does_not_force_wiki_after_model_decides_to_answer():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="解释星河工程的行业背景")
|
|
raw = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-failed",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["星河工程"]},
|
|
}
|
|
],
|
|
)
|
|
raw_result = ToolMessage(
|
|
content='{"ok":false,"error":{"code":"PROVIDER_UNAVAILABLE"}}',
|
|
tool_call_id="raw-failed",
|
|
name="ordinary_knowledge_search",
|
|
)
|
|
|
|
final = middleware.wrap_model_call(
|
|
_request([user, raw, raw_result], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="原始材料暂不可用。一般而言,该类工程需要结合具体行业判断。"
|
|
),
|
|
)
|
|
assert final.content.startswith("原始材料暂不可用")
|
|
assert final.tool_calls == []
|
|
|
|
|
|
def test_answer_after_raw_result_does_not_force_wiki_search():
|
|
user = HumanMessage(content="新闻讲的什么")
|
|
result = SmartReasoningRetrievalMiddleware().wrap_model_call(
|
|
_request(
|
|
_raw_baseline(user),
|
|
tools=[
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
],
|
|
),
|
|
lambda _request: AIMessage(content="直接回答"),
|
|
)
|
|
|
|
assert isinstance(result, AIMessage)
|
|
assert result.content == "直接回答"
|
|
assert result.tool_calls == []
|
|
|
|
|
|
def test_model_provided_natural_question_wiki_pattern_is_normalized():
|
|
user = HumanMessage(content="新闻讲的什么?")
|
|
result = SmartReasoningRetrievalMiddleware().wrap_model_call(
|
|
_request(
|
|
_raw_baseline(user),
|
|
tools=[
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
],
|
|
),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "model-wiki-natural-question",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "新闻讲的什么"},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
|
|
assert isinstance(result, AIMessage)
|
|
assert result.tool_calls[0]["args"]["pattern"] == "新闻"
|
|
|
|
|
|
def test_model_provided_structured_wiki_regex_is_preserved():
|
|
user = HumanMessage(content="梳理火炬、开幕和闭幕时间线")
|
|
result = SmartReasoningRetrievalMiddleware().wrap_model_call(
|
|
_request(
|
|
_raw_baseline(user),
|
|
tools=[
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
],
|
|
),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "model-wiki-quality-regex",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": r"火炬(?:传递|采集)|开幕|闭幕"},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
|
|
assert isinstance(result, AIMessage)
|
|
assert result.tool_calls[0]["args"]["pattern"] == r"火炬(?:传递|采集)|开幕|闭幕"
|
|
|
|
|
|
def test_model_selects_relevant_wiki_hit_without_forcing_every_returned_page():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="完整梳理新闻并核对原始报道")
|
|
raw_history = _raw_baseline(user, results=[{"title": "原始新闻总览"}])
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-search-four",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "新闻"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "wiki_search",
|
|
"result_count": 4,
|
|
"results": [{"page_ref": f"wkpage-{index}"} for index in range(1, 5)],
|
|
}
|
|
),
|
|
tool_call_id="wiki-search-four",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
history = [*raw_history, wiki_search, wiki_result]
|
|
selected_read = middleware.wrap_model_call(
|
|
_request(history, tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "model-selects-third-page",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-3"},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
assert [call["args"]["page_ref"] for call in selected_read.tool_calls] == ["wkpage-3"]
|
|
selected_result = ToolMessage(
|
|
content='{"ok":true,"operation":"wiki_read_page","result_count":1}',
|
|
tool_call_id=selected_read.tool_calls[0]["id"],
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
final = middleware.wrap_model_call(
|
|
_request(
|
|
[*history, selected_read, selected_result],
|
|
tools=tools,
|
|
),
|
|
lambda _request: AIMessage(content="综合原始分片和相关 Wiki 后回答"),
|
|
)
|
|
assert final.content == "综合原始分片和相关 Wiki 后回答"
|
|
assert final.tool_calls == []
|
|
|
|
|
|
@pytest.mark.parametrize("model_requests_continuation", [False, True])
|
|
def test_model_decides_whether_to_continue_long_wiki_page(
|
|
model_requests_continuation,
|
|
):
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="完整梳理长篇 Wiki 后核对原始报道")
|
|
raw_history = _raw_baseline(user)
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-search-long",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "长篇"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "wiki_search",
|
|
"results": [{"page_ref": "wkpage-long"}],
|
|
}
|
|
),
|
|
tool_call_id="wiki-search-long",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
first_read = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-read-long-first",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-long"},
|
|
}
|
|
],
|
|
)
|
|
first_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "wiki_read_page",
|
|
"results": [
|
|
{
|
|
"page_ref": "wkpage-long",
|
|
"complete": False,
|
|
"next_cursor": "cursor-second-segment",
|
|
}
|
|
],
|
|
}
|
|
),
|
|
tool_call_id="wiki-read-long-first",
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
history = [*raw_history, wiki_search, wiki_result, first_read, first_result]
|
|
attempted_call = (
|
|
{
|
|
"id": "model-long-continuation",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {
|
|
"page_ref": "wkpage-long",
|
|
"cursor": "cursor-second-segment",
|
|
},
|
|
}
|
|
if model_requests_continuation
|
|
else {
|
|
"id": "model-raw-before-long-page-complete",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["原始报道"]},
|
|
}
|
|
)
|
|
|
|
continuation = middleware.wrap_model_call(
|
|
_request(history, tools=tools),
|
|
lambda _request: AIMessage(content="", tool_calls=[attempted_call]),
|
|
)
|
|
|
|
assert isinstance(continuation, AIMessage)
|
|
if model_requests_continuation:
|
|
assert [call["name"] for call in continuation.tool_calls] == [
|
|
"ordinary_wiki_read_page"
|
|
]
|
|
assert continuation.tool_calls[0]["args"] == {
|
|
"page_ref": "wkpage-long",
|
|
"cursor": "cursor-second-segment",
|
|
}
|
|
assert continuation.tool_calls[0]["id"] == "model-long-continuation"
|
|
else:
|
|
assert [call["name"] for call in continuation.tool_calls] == [
|
|
"ordinary_knowledge_search"
|
|
]
|
|
assert continuation.tool_calls[0]["args"] == {"queries": ["原始报道"]}
|
|
return
|
|
|
|
second_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "wiki_read_page",
|
|
"results": [
|
|
{
|
|
"page_ref": "wkpage-long",
|
|
"complete": True,
|
|
"next_cursor": None,
|
|
}
|
|
],
|
|
}
|
|
),
|
|
tool_call_id=continuation.tool_calls[0]["id"],
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
raw_search = middleware.wrap_model_call(
|
|
_request([*history, continuation, second_result], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "model-raw-after-long-page-complete",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["原始报道"]},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
|
|
assert isinstance(raw_search, AIMessage)
|
|
assert [call["name"] for call in raw_search.tool_calls] == ["ordinary_knowledge_search"]
|
|
assert raw_search.tool_calls[0]["args"]["queries"] == ["原始报道"]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"read_payload",
|
|
[
|
|
{"ok": False, "error": {"code": "PAGE_READ_FAILED"}},
|
|
{
|
|
"ok": True,
|
|
"results": [
|
|
{
|
|
"page_ref": "wkpage-terminal-attempt",
|
|
"complete": False,
|
|
"next_cursor": "",
|
|
}
|
|
],
|
|
},
|
|
],
|
|
)
|
|
def test_failed_or_non_advanceable_wiki_read_does_not_loop(read_payload):
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="核对报道")
|
|
raw_history = _raw_baseline(user)
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-search-terminal-attempt",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "报道"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content=json.dumps({"ok": True, "results": [{"page_ref": "wkpage-terminal-attempt"}]}),
|
|
tool_call_id="wiki-search-terminal-attempt",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
wiki_read = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-read-terminal-attempt",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-terminal-attempt"},
|
|
}
|
|
],
|
|
)
|
|
wiki_read_result = ToolMessage(
|
|
content=json.dumps(read_payload),
|
|
tool_call_id="wiki-read-terminal-attempt",
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[*raw_history, wiki_search, wiki_result, wiki_read, wiki_read_result],
|
|
tools=tools,
|
|
),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-after-terminal-wiki-attempt",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["原始报道"]},
|
|
}
|
|
],
|
|
),
|
|
)
|
|
|
|
assert isinstance(result, AIMessage)
|
|
assert [call["name"] for call in result.tool_calls] == ["ordinary_knowledge_search"]
|
|
|
|
|
|
def test_repeated_wiki_next_cursor_is_terminal_instead_of_looping():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="梳理长篇页面")
|
|
raw_history = _raw_baseline(user)
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-cursor-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "长篇"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[{"page_ref":"wkpage-loop"}]}',
|
|
tool_call_id="wiki-cursor-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
first_read = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-cursor-first",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-loop"},
|
|
}
|
|
],
|
|
)
|
|
first_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"results": [
|
|
{
|
|
"complete": False,
|
|
"next_cursor": "cursor-repeated",
|
|
}
|
|
],
|
|
}
|
|
),
|
|
tool_call_id="wiki-cursor-first",
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
continuation = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-cursor-second",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {
|
|
"page_ref": "wkpage-loop",
|
|
"cursor": "cursor-repeated",
|
|
},
|
|
}
|
|
],
|
|
)
|
|
repeated_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"results": [
|
|
{
|
|
"complete": False,
|
|
"next_cursor": "cursor-repeated",
|
|
}
|
|
],
|
|
}
|
|
),
|
|
tool_call_id="wiki-cursor-second",
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[
|
|
*raw_history,
|
|
wiki_search,
|
|
wiki_result,
|
|
first_read,
|
|
first_result,
|
|
continuation,
|
|
repeated_result,
|
|
],
|
|
tools=tools,
|
|
),
|
|
lambda _request: AIMessage(content="已根据可读取内容完成回答。"),
|
|
)
|
|
|
|
assert result.content == "已根据可读取内容完成回答。"
|
|
assert result.tool_calls == []
|
|
|
|
|
|
def test_current_turn_duplicate_queries_and_wiki_pages_are_removed():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="梳理工程进展")
|
|
raw_history = _raw_baseline(user, query="星河工程 进展")
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-dedupe-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "星河工程|进展"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"results": [
|
|
{"page_ref": "wkpage-one"},
|
|
{"page_ref": "wkpage-two"},
|
|
],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id="wiki-dedupe-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
first_read = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-dedupe-read-one",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-one"},
|
|
}
|
|
],
|
|
)
|
|
first_result = ToolMessage(
|
|
content='{"ok":true,"results":[{"complete":true}]}',
|
|
tool_call_id="wiki-dedupe-read-one",
|
|
name="ordinary_wiki_read_page",
|
|
)
|
|
history = [
|
|
*raw_history,
|
|
wiki_search,
|
|
wiki_result,
|
|
first_read,
|
|
first_result,
|
|
]
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(history, tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-dedupe-mixed",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {
|
|
"queries": [
|
|
" 星河工程 进展 ",
|
|
"星河工程 建设单位",
|
|
"星河工程 建设单位",
|
|
]
|
|
},
|
|
},
|
|
{
|
|
"id": "wiki-dedupe-repeat",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-one"},
|
|
},
|
|
{
|
|
"id": "wiki-dedupe-new",
|
|
"name": "ordinary_wiki_read_page",
|
|
"args": {"page_ref": "wkpage-two"},
|
|
},
|
|
],
|
|
),
|
|
)
|
|
|
|
assert [call["name"] for call in result.tool_calls] == [
|
|
"ordinary_knowledge_search",
|
|
]
|
|
assert result.tool_calls[0]["args"]["queries"] == ["星河工程 建设单位"]
|
|
assert result.additional_kwargs["knowledge_retrieval_duplicate_actions_skipped"] == 3
|
|
assert result.additional_kwargs["knowledge_retrieval_output_actions_deferred"] == 1
|
|
|
|
|
|
def test_regex_wiki_pattern_and_document_reads_are_deduplicated():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "ordinary_chunk_regex_search"},
|
|
{"name": "ordinary_document_chunks"},
|
|
]
|
|
user = HumanMessage(content="核对工程编号")
|
|
raw_history = _raw_baseline(user)
|
|
actions = [
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-pattern-prior",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "工程|编号"},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="wiki-pattern-prior",
|
|
name="ordinary_wiki_search",
|
|
),
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "regex-prior",
|
|
"name": "ordinary_chunk_regex_search",
|
|
"args": {"pattern": "编号-[0-9]+"},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="regex-prior",
|
|
name="ordinary_chunk_regex_search",
|
|
),
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "chunk-prior",
|
|
"name": "ordinary_document_chunks",
|
|
"args": {
|
|
"identifier": "chunk-1",
|
|
"identifier_type": "chunk_id",
|
|
"page": 1,
|
|
"page_size": 20,
|
|
},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="chunk-prior",
|
|
name="ordinary_document_chunks",
|
|
),
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "document-page-prior",
|
|
"name": "ordinary_document_chunks",
|
|
"args": {
|
|
"identifier": "document-1",
|
|
"identifier_type": "knowledge_id",
|
|
"page": 1,
|
|
"page_size": 20,
|
|
},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="document-page-prior",
|
|
name="ordinary_document_chunks",
|
|
),
|
|
]
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request([*raw_history, *actions], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-pattern-repeat",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "工程|编号"},
|
|
},
|
|
{
|
|
"id": "regex-repeat",
|
|
"name": "ordinary_chunk_regex_search",
|
|
"args": {"pattern": "编号-[0-9]+"},
|
|
},
|
|
{
|
|
"id": "chunk-repeat-with-inert-pagination",
|
|
"name": "ordinary_document_chunks",
|
|
"args": {
|
|
"identifier": "chunk-1",
|
|
"identifier_type": "chunk_id",
|
|
"page": 99,
|
|
"page_size": 1,
|
|
},
|
|
},
|
|
{
|
|
"id": "document-page-repeat",
|
|
"name": "ordinary_document_chunks",
|
|
"args": {
|
|
"identifier": "document-1",
|
|
"identifier_type": "knowledge_id",
|
|
"page": 1,
|
|
"page_size": 20,
|
|
},
|
|
},
|
|
{
|
|
"id": "document-page-next",
|
|
"name": "ordinary_document_chunks",
|
|
"args": {
|
|
"identifier": "document-1",
|
|
"identifier_type": "knowledge_id",
|
|
"page": 2,
|
|
"page_size": 20,
|
|
},
|
|
},
|
|
],
|
|
),
|
|
)
|
|
|
|
assert [call["id"] for call in result.tool_calls] == ["document-page-next"]
|
|
assert result.additional_kwargs["knowledge_retrieval_duplicate_actions_skipped"] == 4
|
|
|
|
|
|
def test_duplicate_only_call_preserves_model_answer_and_ends_without_reread():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
]
|
|
user = HumanMessage(content="梳理新闻")
|
|
raw_history = _raw_baseline(user, query="新闻")
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-only-duplicate-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "新闻"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="wiki-only-duplicate-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request([*raw_history, wiki_search, wiki_result], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="依据现有资料回答。",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-only-duplicate",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["新闻"]},
|
|
}
|
|
],
|
|
response_metadata={"finish_reason": "tool_calls"},
|
|
),
|
|
)
|
|
|
|
assert result.content == "依据现有资料回答。"
|
|
assert result.tool_calls == []
|
|
assert result.response_metadata["finish_reason"] == "stop"
|
|
|
|
|
|
def test_duplicate_raw_before_wiki_suppresses_only_that_tool_and_keeps_skills():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "local_calculator"},
|
|
]
|
|
user = HumanMessage(content="介绍特朗普生平")
|
|
first_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-first-content",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["特朗普 生平"]},
|
|
}
|
|
],
|
|
)
|
|
first_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "knowledge_search",
|
|
"results": [
|
|
{
|
|
"knowledge_base_id": "kb-news",
|
|
"chunk_id": "provider-chunk-1",
|
|
"title": "特朗普生平.txt",
|
|
"content": "唐纳德·特朗普于1946年出生,曾任美国总统并从事商业活动。",
|
|
}
|
|
],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id="raw-first-content",
|
|
name="ordinary_knowledge_search",
|
|
)
|
|
repeated_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-rephrased-content",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["唐纳德特朗普 经历"]},
|
|
}
|
|
],
|
|
)
|
|
repeated_result = ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "knowledge_search",
|
|
"results": [
|
|
{
|
|
"knowledge_base_id": "kb-news",
|
|
"chunk_id": "provider-chunk-remapped",
|
|
"title": "特朗普生平.txt",
|
|
"content": " 唐纳德·特朗普于1946年出生,\n曾任美国总统并从事商业活动。 ",
|
|
}
|
|
],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id="raw-rephrased-content",
|
|
name="ordinary_knowledge_search",
|
|
)
|
|
requests: list[ModelRequest] = []
|
|
|
|
def handler(request: ModelRequest):
|
|
requests.append(request)
|
|
return AIMessage(content="根据已经检索到的资料,特朗普出生于1946年。")
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[
|
|
user,
|
|
first_search,
|
|
first_result,
|
|
repeated_search,
|
|
repeated_result,
|
|
],
|
|
tools=tools,
|
|
),
|
|
handler,
|
|
)
|
|
|
|
assert result.content == "根据已经检索到的资料,特朗普出生于1946年。"
|
|
assert _tool_names(requests[0]) == [
|
|
"ordinary_wiki_search",
|
|
"ordinary_wiki_read_page",
|
|
"local_calculator",
|
|
]
|
|
assert requests[0].tool_choice == "auto"
|
|
stop_prompts = [
|
|
message
|
|
for message in requests[0].messages
|
|
if isinstance(message, HumanMessage)
|
|
and message.name == "smart_reasoning_no_novel_evidence"
|
|
]
|
|
assert len(stop_prompts) == 1
|
|
assert stop_prompts[0].additional_kwargs["hide_from_ui"] is True
|
|
assert (
|
|
stop_prompts[0].additional_kwargs["blocked_retrieval_scope"]
|
|
== "ordinary_knowledge_search"
|
|
)
|
|
|
|
|
|
def test_duplicate_raw_after_wiki_verification_stops_retrieval_but_keeps_skills():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_chunk_regex_search"},
|
|
{"name": "ordinary_document_chunks"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "local_calculator"},
|
|
]
|
|
|
|
def retrieval(
|
|
call_id: str,
|
|
tool_name: str,
|
|
results: list[dict],
|
|
) -> list[AIMessage | ToolMessage]:
|
|
return [
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": call_id,
|
|
"name": tool_name,
|
|
"args": {"queries": ["特朗普 生平"]},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content=json.dumps(
|
|
{"ok": True, "results": results},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id=call_id,
|
|
name=tool_name,
|
|
),
|
|
]
|
|
|
|
repeated_content = "唐纳德·特朗普于1946年出生,曾任美国总统并从事商业活动。"
|
|
messages = [
|
|
HumanMessage(content="介绍特朗普生平"),
|
|
*retrieval(
|
|
"raw-first",
|
|
"ordinary_knowledge_search",
|
|
[
|
|
{
|
|
"knowledge_base_id": "kb-news",
|
|
"chunk_id": "provider-chunk-1",
|
|
"title": "特朗普生平.txt",
|
|
"content": repeated_content,
|
|
}
|
|
],
|
|
),
|
|
*retrieval(
|
|
"wiki-search",
|
|
"ordinary_wiki_search",
|
|
[
|
|
{
|
|
"knowledge_base_id": "kb-news",
|
|
"page_ref": "wiki-page:v1:donald-trump",
|
|
"title": "唐纳德·特朗普",
|
|
"summary": "人物索引摘要。",
|
|
}
|
|
],
|
|
),
|
|
*retrieval(
|
|
"wiki-read",
|
|
"ordinary_wiki_read_page",
|
|
[
|
|
{
|
|
"knowledge_base_id": "kb-news",
|
|
"page_ref": "wiki-page:v1:donald-trump",
|
|
"title": "唐纳德·特朗普",
|
|
"content_markdown": "# 唐纳德·特朗普\n\n人物页面正文。",
|
|
}
|
|
],
|
|
),
|
|
*retrieval(
|
|
"raw-verify",
|
|
"ordinary_knowledge_search",
|
|
[
|
|
{
|
|
"knowledge_base_id": "kb-news",
|
|
"chunk_id": "provider-chunk-remapped",
|
|
"title": "特朗普生平.txt",
|
|
"content": f" {repeated_content[:18]}\n{repeated_content[18:]} ",
|
|
}
|
|
],
|
|
),
|
|
]
|
|
requests: list[ModelRequest] = []
|
|
|
|
def handler(request: ModelRequest):
|
|
requests.append(request)
|
|
return AIMessage(content="根据完整检索链路回答。")
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(messages, tools=tools),
|
|
handler,
|
|
)
|
|
|
|
assert result.content == "根据完整检索链路回答。"
|
|
assert _tool_names(requests[0]) == ["local_calculator"]
|
|
stop_prompts = [
|
|
message
|
|
for message in requests[0].messages
|
|
if isinstance(message, HumanMessage)
|
|
and message.name == "smart_reasoning_no_novel_evidence"
|
|
]
|
|
assert len(stop_prompts) == 1
|
|
assert stop_prompts[0].additional_kwargs["blocked_retrieval_scope"] == "all"
|
|
|
|
|
|
def test_same_title_with_different_raw_content_does_not_stop_retrieval():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
]
|
|
user = HumanMessage(content="介绍特朗普生平")
|
|
history = []
|
|
for suffix, content in [
|
|
("one", "唐纳德·特朗普于1946年出生,曾任美国总统并从事商业活动。"),
|
|
("two", "特朗普在纽约成长,这一段包含与上一分片不同的原文信息。"),
|
|
]:
|
|
history.extend(
|
|
[
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": f"raw-{suffix}",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": [f"特朗普 {suffix}"]},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content=json.dumps(
|
|
{
|
|
"ok": True,
|
|
"operation": "knowledge_search",
|
|
"results": [
|
|
{
|
|
"knowledge_base_id": "kb-news",
|
|
"chunk_id": f"chunk-{suffix}",
|
|
"title": "特朗普生平.txt",
|
|
"content": content,
|
|
}
|
|
],
|
|
},
|
|
ensure_ascii=False,
|
|
),
|
|
tool_call_id=f"raw-{suffix}",
|
|
name="ordinary_knowledge_search",
|
|
),
|
|
]
|
|
)
|
|
requests: list[ModelRequest] = []
|
|
|
|
def handler(request: ModelRequest):
|
|
requests.append(request)
|
|
return AIMessage(content="资料仍有新增。")
|
|
|
|
middleware.wrap_model_call(
|
|
_request([user, *history], tools=tools),
|
|
handler,
|
|
)
|
|
|
|
assert _tool_names(requests[0]) == [
|
|
"ordinary_knowledge_search",
|
|
"ordinary_wiki_search",
|
|
]
|
|
assert not any(
|
|
isinstance(message, HumanMessage)
|
|
and message.name == "smart_reasoning_no_novel_evidence"
|
|
for message in requests[0].messages
|
|
)
|
|
|
|
|
|
def test_duplicate_retrieval_does_not_drop_delivery_tools_or_leak_draft():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "write_file"},
|
|
{"name": "present_files"},
|
|
]
|
|
user = HumanMessage(content="整理新闻并生成报告")
|
|
raw_history = _raw_baseline(user, query="新闻")
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-delivery-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "新闻"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="wiki-delivery-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request([*raw_history, wiki_search, wiki_result], tools=tools),
|
|
lambda _request: AIMessage(
|
|
content="报告已经完成。",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-delivery-duplicate",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["新闻"]},
|
|
},
|
|
{
|
|
"id": "write-delivery-report",
|
|
"name": "write_file",
|
|
"args": {"file_path": "report.md", "content": "报告正文"},
|
|
},
|
|
{
|
|
"id": "present-delivery-report",
|
|
"name": "present_files",
|
|
"args": {"paths": ["report.md"]},
|
|
},
|
|
],
|
|
response_metadata={"finish_reason": "tool_calls"},
|
|
),
|
|
)
|
|
|
|
assert result.content == ""
|
|
assert [call["name"] for call in result.tool_calls] == [
|
|
"write_file",
|
|
"present_files",
|
|
]
|
|
assert result.additional_kwargs["knowledge_retrieval_duplicate_actions_skipped"] == 1
|
|
assert "knowledge_retrieval_output_actions_deferred" not in (result.additional_kwargs)
|
|
assert result.response_metadata["finish_reason"] == "tool_calls"
|
|
|
|
|
|
@pytest.mark.parametrize("asynchronous", [False, True])
|
|
def test_duplicate_only_empty_retries_once_for_tool_free_synthesis(asynchronous):
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
{"name": "ordinary_wiki_read_page"},
|
|
{"name": "local_calculator"},
|
|
]
|
|
user = HumanMessage(content="开幕式主题曲是什么?")
|
|
raw_history = _raw_baseline(
|
|
user,
|
|
results=[
|
|
{
|
|
"title": "开幕式原文",
|
|
"content": "开幕式主题曲《友爱之声》由合唱团演唱。",
|
|
}
|
|
],
|
|
)
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-synthesis-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "开幕式|主题曲"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="wiki-synthesis-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
requests: list[ModelRequest] = []
|
|
|
|
def response_for(request: ModelRequest) -> AIMessage:
|
|
requests.append(request)
|
|
if len(requests) == 1:
|
|
return AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-duplicate-empty",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["开幕式主题曲是什么?"]},
|
|
}
|
|
],
|
|
response_metadata={"finish_reason": "tool_calls"},
|
|
)
|
|
return AIMessage(content="开幕式主题曲是《互助之声》。")
|
|
|
|
request = _request(
|
|
[*raw_history, wiki_search, wiki_result],
|
|
tools=tools,
|
|
)
|
|
if asynchronous:
|
|
|
|
async def handler(current_request):
|
|
return response_for(current_request)
|
|
|
|
result = asyncio.run(middleware.awrap_model_call(request, handler))
|
|
else:
|
|
result = middleware.wrap_model_call(request, response_for)
|
|
|
|
assert len(requests) == 2
|
|
assert _tool_names(requests[1]) == ["local_calculator"]
|
|
assert requests[1].tool_choice == "none"
|
|
assert requests[1].messages[-1].name == ("smart_reasoning_duplicate_synthesis")
|
|
assert requests[1].messages[-1].additional_kwargs["hide_from_ui"] is True
|
|
assert result.content == "开幕式主题曲是《互助之声》。"
|
|
assert result.tool_calls == []
|
|
assert result.additional_kwargs["knowledge_retrieval_stop_reason"] == ("duplicate_only_synthesis")
|
|
|
|
|
|
def test_duplicate_only_empty_uses_safe_fallback_if_synthesis_is_still_empty():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
]
|
|
user = HumanMessage(content="梳理新闻")
|
|
raw_history = _raw_baseline(user, query="新闻")
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-empty-synthesis-search",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "新闻"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="wiki-empty-synthesis-search",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
call_count = 0
|
|
|
|
def handler(_request):
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count == 1:
|
|
return AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "raw-empty-synthesis-repeat",
|
|
"name": "ordinary_knowledge_search",
|
|
"args": {"queries": ["新闻"]},
|
|
}
|
|
],
|
|
)
|
|
return AIMessage(content="")
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[*raw_history, wiki_search, wiki_result],
|
|
tools=tools,
|
|
),
|
|
handler,
|
|
)
|
|
|
|
assert call_count == 2
|
|
assert result.content == SMART_REASONING_DUPLICATE_SYNTHESIS_FALLBACK
|
|
|
|
|
|
def test_final_answer_does_not_rewrite_similar_name_from_another_entity():
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
tools = [
|
|
{"name": "ordinary_knowledge_search"},
|
|
{"name": "ordinary_wiki_search"},
|
|
]
|
|
user = HumanMessage(content="B赛事的主题曲是什么?并与A赛事对比。")
|
|
raw_history = _raw_baseline(
|
|
user,
|
|
results=[
|
|
{
|
|
"title": "A赛事新闻原文",
|
|
"content": "A赛事主题曲《友爱之声》由合唱团演唱。",
|
|
}
|
|
],
|
|
)
|
|
wiki_search = AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "wiki-search-name",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"pattern": "A赛事|B赛事|主题曲"},
|
|
}
|
|
],
|
|
)
|
|
wiki_result = ToolMessage(
|
|
content='{"ok":true,"results":[]}',
|
|
tool_call_id="wiki-search-name",
|
|
name="ordinary_wiki_search",
|
|
)
|
|
|
|
result = middleware.wrap_model_call(
|
|
_request(
|
|
[
|
|
*raw_history,
|
|
wiki_search,
|
|
wiki_result,
|
|
],
|
|
tools=tools,
|
|
),
|
|
lambda _request: AIMessage(content=("B赛事的主题曲是《友谊之声》;库内资料显示A赛事的主题曲是《友爱之声》。")),
|
|
)
|
|
|
|
assert isinstance(result, AIMessage)
|
|
assert result.content == ("B赛事的主题曲是《友谊之声》;库内资料显示A赛事的主题曲是《友爱之声》。")
|
|
assert "knowledge_retrieval_fidelity_corrections" not in result.additional_kwargs
|
|
|
|
|
|
@pytest.mark.parametrize("tool_name", sorted(SMART_REASONING_TOOL_NAMES))
|
|
def test_every_smart_retrieval_tool_is_removed_from_an_old_turn(tool_name):
|
|
messages = [
|
|
HumanMessage(content="旧问题"),
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "old-call",
|
|
"name": tool_name,
|
|
"args": {"secret": "old-argument"},
|
|
}
|
|
],
|
|
),
|
|
ToolMessage(
|
|
content="old-result-body",
|
|
tool_call_id="old-call",
|
|
name=tool_name,
|
|
),
|
|
HumanMessage(content="新问题"),
|
|
]
|
|
|
|
sanitized = sanitize_smart_retrieval_history(messages)
|
|
|
|
assert sanitized is not None
|
|
rendered = "\n".join(str(message.model_dump()) for message in sanitized)
|
|
assert "old-argument" not in rendered
|
|
assert "old-result-body" not in rendered
|
|
assert SMART_RETRIEVAL_HISTORY_MARKER in rendered
|
|
_assert_tool_protocol_is_valid(sanitized)
|
|
|
|
|
|
def test_raw_provider_non_retrieval_call_in_mixed_bundle_stays_paired():
|
|
messages = [
|
|
HumanMessage(content="旧问题"),
|
|
AIMessage(
|
|
content="",
|
|
additional_kwargs={
|
|
"tool_calls": [
|
|
{
|
|
"id": "raw-smart",
|
|
"type": "function",
|
|
"function": {
|
|
"name": "ordinary_wiki_search",
|
|
"arguments": '{"patterns":["secret"]}',
|
|
},
|
|
},
|
|
{
|
|
"id": "raw-other",
|
|
"type": "function",
|
|
"function": {
|
|
"name": "local_calculator",
|
|
"arguments": '{"expression":"2+2"}',
|
|
},
|
|
},
|
|
]
|
|
},
|
|
response_metadata={"finish_reason": "tool_calls"},
|
|
),
|
|
ToolMessage(
|
|
content="secret-result",
|
|
tool_call_id="raw-smart",
|
|
name="ordinary_wiki_search",
|
|
),
|
|
ToolMessage(
|
|
content="4",
|
|
tool_call_id="raw-other",
|
|
name="local_calculator",
|
|
),
|
|
HumanMessage(content="新问题"),
|
|
]
|
|
|
|
sanitized = sanitize_smart_retrieval_history(messages)
|
|
|
|
assert sanitized is not None
|
|
old_ai = sanitized[1]
|
|
assert isinstance(old_ai, AIMessage)
|
|
raw_calls = old_ai.additional_kwargs["tool_calls"]
|
|
assert [call["id"] for call in raw_calls] == ["raw-other"]
|
|
assert old_ai.response_metadata["finish_reason"] == "tool_calls"
|
|
assert any(isinstance(message, ToolMessage) and message.tool_call_id == "raw-other" for message in sanitized)
|
|
assert "secret-result" not in "\n".join(str(message.model_dump()) for message in sanitized)
|
|
_assert_tool_protocol_is_valid(sanitized)
|
|
|
|
|
|
@pytest.mark.parametrize("asynchronous", [False, True])
|
|
def test_fortieth_call_hides_retrieval_tools_and_forces_plain_final(asynchronous):
|
|
messages = [HumanMessage(content="需要多轮检索的问题")]
|
|
messages.extend(AIMessage(content=f"intermediate-{index}") for index in range(39))
|
|
middleware = SmartReasoningRetrievalMiddleware()
|
|
request = _request(
|
|
messages,
|
|
tools=[
|
|
{"name": "ordinary_wiki_search"},
|
|
{
|
|
"type": "function",
|
|
"function": {"name": "ordinary_document_chunks"},
|
|
},
|
|
{"name": "local_calculator"},
|
|
],
|
|
)
|
|
captured = {}
|
|
|
|
def response_for(patched):
|
|
captured["request"] = patched
|
|
return ModelResponse(
|
|
result=[
|
|
AIMessage(
|
|
content="",
|
|
tool_calls=[
|
|
{
|
|
"id": "ignored-call",
|
|
"name": "ordinary_wiki_search",
|
|
"args": {"patterns": ["repeat"]},
|
|
}
|
|
],
|
|
additional_kwargs={
|
|
"tool_calls": [
|
|
{
|
|
"id": "ignored-call",
|
|
"type": "function",
|
|
"function": {
|
|
"name": "ordinary_wiki_search",
|
|
"arguments": '{"patterns":["repeat"]}',
|
|
},
|
|
}
|
|
]
|
|
},
|
|
response_metadata={"finish_reason": "tool_calls"},
|
|
)
|
|
]
|
|
)
|
|
|
|
if asynchronous:
|
|
|
|
async def async_handler(patched):
|
|
return response_for(patched)
|
|
|
|
result = asyncio.run(middleware.awrap_model_call(request, async_handler))
|
|
else:
|
|
result = middleware.wrap_model_call(request, response_for)
|
|
|
|
patched = captured["request"]
|
|
assert _tool_names(patched) == ["local_calculator"]
|
|
assert patched.tool_choice == "none"
|
|
assert SMART_REASONING_FINAL_SYNTHESIS_PROMPT in str(patched.messages[-1].content)
|
|
assert patched.messages[-1].additional_kwargs["hide_from_ui"] is True
|
|
|
|
assert isinstance(result, ModelResponse)
|
|
final = result.result[0]
|
|
assert isinstance(final, AIMessage)
|
|
assert final.tool_calls == []
|
|
assert final.content == SMART_REASONING_LIMIT_FALLBACK
|
|
assert final.additional_kwargs["knowledge_retrieval_stop_reason"] == ("iteration_limit")
|
|
assert final.response_metadata["finish_reason"] == "stop"
|
|
|
|
|
|
def test_no_forty_first_model_call_is_allowed():
|
|
messages = [HumanMessage(content="当前问题")]
|
|
messages.extend(AIMessage(content=f"call-{index}") for index in range(40))
|
|
called = False
|
|
|
|
def handler(_request):
|
|
nonlocal called
|
|
called = True
|
|
return AIMessage(content="should not run")
|
|
|
|
result = SmartReasoningRetrievalMiddleware().wrap_model_call(_request(messages, tools=[{"name": "ordinary_wiki_search"}]), handler)
|
|
|
|
assert called is False
|
|
assert isinstance(result, AIMessage)
|
|
assert result.content == SMART_REASONING_LIMIT_FALLBACK
|
|
assert result.additional_kwargs["knowledge_retrieval_stop_reason"] == ("iteration_limit")
|
|
|
|
|
|
def test_middleware_mounts_only_for_smart_mode_and_keeps_clarification_last(
|
|
monkeypatch,
|
|
):
|
|
import deerflow.agents.lead_agent.agent as factory
|
|
|
|
app_config = SimpleNamespace(
|
|
token_usage=SimpleNamespace(enabled=False),
|
|
skill_evolution=SimpleNamespace(enabled=False, review_worker=SimpleNamespace(enabled=False)),
|
|
knowledge=SimpleNamespace(enabled=True, rag_limit=5, rag_enabled=True),
|
|
tool_search=SimpleNamespace(enabled=False),
|
|
skill_stop=SimpleNamespace(enabled=False, skill_names=[]),
|
|
skills=SimpleNamespace(container_path="/mnt/skills"),
|
|
get_model_config=lambda _name: None,
|
|
)
|
|
monkeypatch.setattr(factory, "build_lead_runtime_middlewares", lambda **_kwargs: [])
|
|
monkeypatch.setattr(factory, "_create_context_reduction_middleware", lambda **_kwargs: None)
|
|
monkeypatch.setattr(
|
|
factory,
|
|
"get_memory_runtime_settings",
|
|
lambda: SimpleNamespace(enabled=False),
|
|
)
|
|
monkeypatch.setattr("deerflow.models.vision.vision_enabled", lambda *_args, **_kwargs: False)
|
|
|
|
classic = factory._build_middlewares(
|
|
{
|
|
"context": {
|
|
"knowledge_retrieval_mode": "classic",
|
|
"rag_mode_enabled": True,
|
|
}
|
|
},
|
|
model_name=None,
|
|
app_config=app_config,
|
|
)
|
|
smart = factory._build_middlewares(
|
|
{
|
|
"context": {
|
|
"knowledge_retrieval_mode": "smart_reasoning",
|
|
"rag_mode_enabled": True,
|
|
}
|
|
},
|
|
model_name=None,
|
|
app_config=app_config,
|
|
)
|
|
|
|
assert not any(isinstance(middleware, SmartReasoningRetrievalMiddleware) for middleware in classic)
|
|
assert sum(isinstance(middleware, SmartReasoningRetrievalMiddleware) for middleware in smart) == 1
|
|
assert sum(isinstance(middleware, RagCitationMiddleware) for middleware in classic) == 1
|
|
assert not any(isinstance(middleware, RagCitationMiddleware) for middleware in smart)
|
|
assert sum(isinstance(middleware, KnowledgeRagMiddleware) for middleware in classic) == 1
|
|
assert not any(isinstance(middleware, KnowledgeRagMiddleware) for middleware in smart)
|
|
assert isinstance(classic[-1], ClarificationMiddleware)
|
|
assert isinstance(smart[-1], ClarificationMiddleware)
|
|
|
|
|
|
def test_setup_round_cap_is_inserted_before_final_clarification(monkeypatch):
|
|
import deerflow.agents.lead_agent.agent as factory
|
|
|
|
model_config = SimpleNamespace(max_input_tokens=None)
|
|
app_config = SimpleNamespace(
|
|
token_usage=SimpleNamespace(enabled=False),
|
|
skill_evolution=SimpleNamespace(enabled=False, review_worker=SimpleNamespace(enabled=False)),
|
|
knowledge=SimpleNamespace(enabled=True, rag_limit=5, rag_enabled=True),
|
|
tool_search=SimpleNamespace(enabled=False),
|
|
skill_stop=SimpleNamespace(enabled=False, skill_names=[]),
|
|
skills=SimpleNamespace(container_path="/mnt/skills"),
|
|
get_model_config=lambda _name: model_config,
|
|
)
|
|
monkeypatch.setattr(factory, "build_lead_runtime_middlewares", lambda **_kwargs: [])
|
|
monkeypatch.setattr(factory, "_create_context_reduction_middleware", lambda **_kwargs: None)
|
|
monkeypatch.setattr(
|
|
factory,
|
|
"get_memory_runtime_settings",
|
|
lambda: SimpleNamespace(enabled=False),
|
|
)
|
|
monkeypatch.setattr("deerflow.models.vision.vision_enabled", lambda *_args, **_kwargs: False)
|
|
|
|
round_cap = WritingSetupRoundCapMiddleware(max_rounds=3)
|
|
middlewares = factory._build_setup_middlewares(
|
|
{"context": {"is_writing_setup": True}},
|
|
"test-model",
|
|
round_cap,
|
|
app_config=app_config,
|
|
)
|
|
|
|
assert middlewares[-2] is round_cap
|
|
assert isinstance(middlewares[-1], ClarificationMiddleware)
|
|
|
|
|
|
def test_rag_citation_middleware_fails_closed_for_smart_mode() -> None:
|
|
smart_request = _request(
|
|
[HumanMessage(content="查制度")],
|
|
runtime=SimpleNamespace(
|
|
context={
|
|
"knowledge_retrieval_mode": "smart_reasoning",
|
|
"rag_mode_enabled": True,
|
|
},
|
|
config={
|
|
"configurable": {"rag_mode_enabled": True},
|
|
},
|
|
),
|
|
)
|
|
assert RagCitationMiddleware._enabled(smart_request) is False
|
|
assert RagCitationMiddleware._patch(smart_request) is None
|
|
|
|
classic_request = _request(
|
|
[HumanMessage(content="查制度")],
|
|
runtime=SimpleNamespace(
|
|
context={
|
|
"knowledge_retrieval_mode": "classic",
|
|
"rag_mode_enabled": True,
|
|
},
|
|
config={},
|
|
),
|
|
)
|
|
assert RagCitationMiddleware._enabled(classic_request) is True
|
|
|
|
|
|
def test_smart_prompt_removes_classic_reference_contracts() -> None:
|
|
import deerflow.agents.lead_agent.agent as factory
|
|
|
|
base = "before<citations>must add Sources</citations>middle<rag_citation_mode>must cite [1]</rag_citation_mode>after"
|
|
cleaned = factory._without_classic_citation_contracts(base)
|
|
assert cleaned == "beforemiddleafter"
|
|
assert "不套用经典参考文献模式" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "若问题不需要所选知识库中的专属事实,可直接回答" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "第一个检索动作必须调用 ordinary_knowledge_search" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "再判断是否需要调用 ordinary_wiki_search" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "不要同时输出回答正文" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "不得把检索、技能和最终回答作为同一批并行动作发出" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "不要求每轮同时覆盖所有检索面" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "可以用稳定的通用知识解释背景" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "可以正常使用当前智能体已配置的技能" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "search_skills、skill_list、skill_view" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "候选扩展词" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "删减、组合或改写" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "不得重复相同 query" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "专名、作品/文件/活动标题、日期、时间、数字、单位和数量关系" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "证据未明确给出的细节不要补写" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "不要求使用 [1]、[2] 等编号" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|
|
assert "不要求生成文末参考文献列表" in factory._SMART_REASONING_KNOWLEDGE_SCOPE_PROMPT
|